package cup;

import es.ucm.fdi.plg.evlib.Atribucion;
import es.ucm.fdi.plg.evlib.Atributo;
import es.ucm.fdi.plg.evlib.SemFun;
import es.ucm.fdi.plg.evlib.TAtributos;
import java.util.ArrayList;
import java.util.Iterator;
import ts.*;

class CreaTs implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return ts.Funciones.creaTS();
	}
}

class CreaNatural implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return ts.Funciones.creaNatural();
	}

}

class CreaInt implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return ts.Funciones.creaInteger();
	}
}

class CreaBool implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return ts.Funciones.creaBoolean();
	}
}

class CreaChar implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return ts.Funciones.creaCharacter();
	}
}

class ClaseConst implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return "const";
	}
}

class CreaFloat implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return ts.Funciones.creaFloat();
	}
}

class Asignacion implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return args[0].valor();
	}
}



class Asignacion0 implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return 0;
	}
}

class Asignacion1 implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return 1;
	}
}


class Asignacion2 implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return 2;
	}
}


class Asignacion3 implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return 3;
	}
}

class AsignacionP implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		Object a = args[0].valor();
		return a;
	}
}

class AsignacionL implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		TablaSimbolos ts = (TablaSimbolos) args[0].valor();
		return ts;
	}
}

class AsignacionSuma1 implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return (int) args[0].valor() + 1;
	}
}

class AsignacionSuma1P implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		Object o = args[0].valor();
		return (int) args[0].valor() + 1;
	}
}

class AsignacionSuma2 implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return (int) args[0].valor() + 2;
	}
}

class AsignacionSuma3 implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return (int) args[0].valor() + 3;
	}
}

class AsignacionSuma4 implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return (int) args[0].valor() + 4;
	}
}


class AsignacionSuma5 implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return (int) args[0].valor() + 5;
	}
}

class AsignacionSuma13 implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return (int) args[0].valor() + 13;
	}
}

class AsignacionSuma14 implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		return (int) args[0].valor() + 14;
	}
}


class AsignacionMenos implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		String a = "-";
		a += args[0].valor();

		return a;
	}
}



class CodVacio implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.creaCod();
	}
}



class CreaErrores implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return ts.Funciones.creaErrores();
	}
}

class AsignTrue implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return "true";
	}
}

class AsignacionFalse implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return "false";
	}
}

class IniciaTipoConst implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		Tipo t = (Tipo) args[0].valor();
		String num = (String) args[1].valor();
		try {
			if (t.getTipo().equals("natural"))
				((TipoNat) t).setValor(Integer.parseInt(num));
			if (t.getTipo().equals("integer"))
				((TipoInt) t).setValor(Integer.parseInt(num));
			if (t.getTipo().equals("character"))
				((TipoChar) t).setValor(num.charAt(1));
			if (t.getTipo().equals("float"))
				((TipoFloat) t).setValor(Float.parseFloat(num));
			if (t.getTipo().equals("boolean"))
				((TipoBool) t).setValor(Boolean.getBoolean(num));
		} catch (Exception e) {
		}
		;

		return Funciones.tipoDe(t, num);
	}
}

class AsignCodConst implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		Tipo tipo = (Tipo) args[0].valor();
		String num = (String) args[1].valor();
		ArrayList<String> a = Funciones.creaCod();
		a.add("apila(" + Funciones.valorDe(tipo, num) + ")");

		return a;
	}
}

class CodApilaValor implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String num = (String) args[0].valor();
		ArrayList<String> a = Funciones.creaCod();
		a.add("apila(" + num + ")");

		return a;
	}
}

class CodApilaChar implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String character = (String) args[0].valor();
		ArrayList<String> a = ts.Funciones.creaCod();
		a.add("apila(" + (int) character.charAt(1) + ")");

		return a;
	}
}

class CodApilaTrue implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> a = Funciones.creaCod();
		a.add("apila(1)");
		return a;
	}
}

class CodApilaFalse implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> a = Funciones.creaCod();
		a.add("apila(0)");
		return a;
	}
}

class AsignCodDecConst implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String s = "desapila_dir("
				+ (((TablaSimbolos) args[1].valor()).getDir((String) args[2]
						.valor())) + ")";
		return Funciones.concatenaCod((ArrayList<String>) args[0].valor(), s,
				(ArrayList<Boolean>) args[3].valor(), (Tipo) args[4].valor());
	}
}

class AsignTSDecConsts implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.creaTS((String) args[0].valor(),
				(String) args[1].valor(), (Tipo) args[2].valor(), 2);
	}
}

class UnirDosTipos implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.unirTipos((Tipo) args[0].valor(),
				(Tipo) args[1].valor());
	}
}

class UnirTresTipos implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.unirTipos((Tipo) args[0].valor(),
				(Tipo) args[1].valor(), (Tipo) args[2].valor());
	}
}

class UnirCuatroTipos implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.unirTipos((Tipo) args[0].valor(),
				(Tipo) args[1].valor(), (Tipo) args[2].valor(),
				(Tipo) args[3].valor());
	}
}

class UnirCincoTipos implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return ts.Funciones.unirTipos((Tipo) args[0].valor(),
				(Tipo) args[1].valor(), (Tipo) args[2].valor(),
				(Tipo) args[3].valor());
	}
}

class CopiaErroresOrDuplicado implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String id = (String) args[2].valor();
		boolean duplicado = ((TablaSimbolos) args[1].valor()).existeId(id);
		return Funciones.unirErrores((ArrayList<Boolean>) args[0].valor(),
				duplicado, 0);
	}
}

class UnirErroresOrDuplicado implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String id = (String) args[3].valor();
		boolean duplicado = ((TablaSimbolos) args[2].valor()).existeId(id);
		ArrayList<Boolean> errores = Funciones.unirErrores(
				(ArrayList<Boolean>) args[0].valor(),
				(ArrayList<Boolean>) args[1].valor());
		return Funciones.unirErrores(errores, duplicado, 0);
	}
}

class SumaDirConTam implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return (int) args[0].valor()
				+ Funciones.tamDe((Tipo) args[1].valor(),
						(String) args[2].valor());
	}
}

class DirConTam implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones
				.tamDe((Tipo) args[0].valor(), (String) args[1].valor());
	}
}

class AnadirTS implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.creaTS((TablaSimbolos) args[0].valor(),
				(String) args[2].valor(), (String) args[3].valor(),
				(ArrayList<Boolean>) args[1].valor(), (Tipo) args[4].valor(),
				(int) args[5].valor());
	}
}

class AnadirTSTipo implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones
				.creaTS((TablaSimbolos) args[0].valor(),
						(String) args[2].valor(), (String) args[3].valor(),
						(ArrayList<Boolean>) args[1].valor(),
						(Tipo) args[4].valor(), 0);
	}
}

class Concat2CodDesapila implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String s = "desapila_dir("
				+ (((TablaSimbolos) args[2].valor()).getDir((String) args[3]
						.valor())) + ")";

		return Funciones.concatenaCod((ArrayList<String>) args[0].valor(),
				(ArrayList<String>) args[1].valor(), s,
				(ArrayList<Boolean>) args[4].valor(), (Tipo) args[5].valor());
	}
}

class ConcatenaDosCod implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> cod = new ArrayList<String>();
		cod.addAll((ArrayList<String>) args[0].valor());
		cod.addAll((ArrayList<String>) args[1].valor());
		return cod;
	}
}

class CopiaErrores implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.copiaErrores((ArrayList<Boolean>) args[0].valor());
	}
}

class CreaTipo implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return new Tipo();
	}
}

class CopiaCodigo implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.copiaCod((ArrayList<String>) args[0].valor(),
				(ArrayList<Boolean>) args[1].valor(), (Tipo) args[2].valor());
	}
}

class ClaseVar implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return "var";
	}
}

class ClaseValor implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return "valor";
	}
}

class ClaseTipo implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return "tipo";
	}
}

class ClaseSubprogram implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return "proc";
	}
}

class CreaCodMen implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("menor");
		return al;
	}
}

class CreaCodMay implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("mayor");
		return al;
	}
}

class CreaCodIgual implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("igual");
		return al;
	}
}

class CreaCodMenIgual implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("menorIgual");
		return al;
	}
}

class CreaCodMayIgual implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("mayorIgual");
		return al;
	}
}


class CreaCodNoIgual implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("distinto");
		return al;
	}
}

class CreaCodMas implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("suma");
		return al;
	}
}

class CreaCodMenos implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("resta");
		return al;
	}
}

class CreaCodOr implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("or");
		return al;
	}
}

class CreaCodMul implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("multiplica");
		return al;
	}
}

class CreaCodDiv implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("divide");
		return al;
	}
}

class CreaCodMod implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("modulo");
		return al;
	}
}

class CreaCodAnd implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("and");
		return al;
	}
}

class CreaCodDespDerecha implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("desplazarDer");
		return al;
	}
}

class CreaCodDespIzq implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("desplazarIzq");
		return al;
	}
}

class CreaCodNot implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("not");
		return al;
	}
}

class CreaCodMenosUnario implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("negativo");
		return al;
	}
}


class CreaCodCastFloat implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("(float)");
		return al;
	}
}

class CreaCodCastNot implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("negativo");
		return al;
	}
}

class CreaCodCastChar implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("(char)");
		return al;
	}
}


class CreaCodCastInt implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("(int)");
		return al;
	}
}

class CreaCodCastNat implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("(nat)");
		return al;
	}
}

class UnirDosErrores implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.unirErrores((ArrayList<Boolean>) args[0].valor(),
				(ArrayList<Boolean>) args[1].valor());
	}
}

class UnirTresErrores implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.unirErrores((ArrayList<Boolean>) args[0].valor(),
				(ArrayList<Boolean>) args[1].valor(),
				(ArrayList<Boolean>) args[2].valor());
	}
}

class UnirCuatroErrores implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.unirErrores((ArrayList<Boolean>) args[0].valor(),
				(ArrayList<Boolean>) args[1].valor(),
				(ArrayList<Boolean>) args[2].valor(),
				(ArrayList<Boolean>) args[3].valor());
	}
}

class UnirCincoErrores implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return ts.Funciones.unirErrores((ArrayList<Boolean>) args[0].valor(),
				(ArrayList<Boolean>) args[1].valor(),
				(ArrayList<Boolean>) args[2].valor(),
				(ArrayList<Boolean>) args[3].valor(),
				(ArrayList<Boolean>) args[4].valor());
	}
}

class ConcatCodProg implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> cod = new ArrayList<String>();
		cod.add("apila(2)");
		cod.add("desapila_dir(1)");
		cod.addAll((ArrayList<String>) args[0].valor());

		if ((int) args[2].valor() == 2)
			cod.add("apila(" + ((int) args[2].valor()) + ")");
		else
			cod.add("apila(" + ((int) args[2].valor() - 1) + ")");
		cod.add("desapila_dir(0)");
		cod.add("ir_a(" + (int) args[3].valor() + ")");
		cod.addAll((ArrayList<String>) args[1].valor());

		return ts.Funciones.concatenaCod(cod,
				(ArrayList<String>) args[4].valor(), "stop",
				(ArrayList<Boolean>) args[5].valor(), (Tipo) args[6].valor());
	}
}

class ConcatCodInsts implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		return Funciones.concatenaCod((ArrayList<String>) args[0].valor(),
				(ArrayList<String>) args[1].valor(),
				(ArrayList<Boolean>) args[2].valor(), (Tipo) args[3].valor());
	}
}

class TipoDeIdConTS implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.tipoDe((String) args[0].valor(),
				((TablaSimbolos) args[1].valor()));
	}
}

class DameTipoDeIdConTS implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		TablaSimbolos ts = (TablaSimbolos) args[1].valor();
		Tipo tipo = ts.getTipo((String) args[0].valor());

		return tipo;
	}
}

class CreaErroresTipoIdent implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		boolean noExisteId = !((TablaSimbolos) args[1].valor())
				.existeId((String) args[0].valor());
		return Funciones.unirErrores(Funciones.creaErrores(), noExisteId, 1);
	}
}

class CreaArray implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.creaArray(Integer.parseInt((String) args[0].valor()),
				(Tipo) args[1].valor());
	}
}

class CreaArrayIdent implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		int tam = ((TablaSimbolos) args[0].valor())
				.getValorNatural((String) args[1].valor());
		return Funciones.creaArray(tam, (Tipo) args[2].valor());
	}
}

class CreaErroresTipoArrayIdent implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		boolean noExisteId = !((TablaSimbolos) args[2].valor())
				.existeId((String) args[1].valor());
		boolean noEsConstante = !((TablaSimbolos) args[2].valor())
				.esConst((String) args[1].valor());
		boolean noEsNatural = !((TablaSimbolos) args[2].valor())
				.esNatural((String) args[1].valor());
		ArrayList<Boolean> errores = Funciones
				.copiaErrores((ArrayList<Boolean>) args[0].valor());

		errores.set(1, errores.get(1) | noExisteId);
		errores.set(2, errores.get(2) | noEsConstante);
		errores.set(3, errores.get(3) | noEsNatural);
		return errores;
	}
}

class DameTamTipo implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		return ((Tipo) args[0].valor()).getTam();
	}
}

class SumaDespConTamTipo implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return (int) args[0].valor() + ((Tipo) args[1].valor()).getTam();
	}
}

class CreaTuplaVacia implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones.creaTuplaVacia();
	}
}

class CreaTupla implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<ParamTupla> campos = (ArrayList<ParamTupla>) args[0].valor();
		ArrayList<Boolean> err = (ArrayList<Boolean>) args[1].valor();
		Tipo tipo = (Tipo) args[2].valor();
		return Funciones.creaTupla(campos, err, tipo);
	}
}

class PrimerCampoTupla implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<ParamTupla> campos = new ArrayList<ParamTupla>();
		ParamTupla campo = new ParamTupla((Tipo) args[0].valor(), 0);
		campos.add(campo);

		return campos;
	}
}

class AddCampoTupla implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<ParamTupla> campos = new ArrayList<ParamTupla>(
				(ArrayList<ParamTupla>) args[0].valor());
		int desp = (int) args[2].valor();
		ParamTupla campo = new ParamTupla((Tipo) args[1].valor(), desp);
		campos.add(campo);
		return campos;
	}
}

class ConcatCodDecs implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> cod = new ArrayList<String>();
		cod.add("apila(2)");
		cod.add("desapila_dir(1)");
		cod.addAll((ArrayList<String>) args[0].valor());
		if ((int) args[2].valor() == 2)
			cod.add("apila(" + ((int) args[2].valor()) + ")");
		else
			cod.add("apila(" + ((int) args[2].valor() - 1) + ")");
		cod.add("desapila_dir(0)");
		cod.add("ir_a(" + (int) args[3].valor() + ")");
		cod.addAll((ArrayList<String>) args[1].valor());
		return cod;
	}
}

class CreaCodSwap1 implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("swap1");
		return al;
	}
}

class CreaCodSwap2 implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("swap2");
		return al;
	}
}

class CopiaErroresInstsIn implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String id = (String) args[1].valor();
		TablaSimbolos ts = (TablaSimbolos) args[2].valor();
		Tipo tipo = (Tipo) args[3].valor();
		boolean asignacionConstante = ts.esConst(id);
		boolean noTipoBasicoIn = !Funciones.esTipoBasico(tipo);

		ArrayList<Boolean> errores = Funciones
				.copiaErrores((ArrayList<Boolean>) args[0].valor());
		errores.set(5, errores.get(5) | noTipoBasicoIn);
		errores.set(4, errores.get(4) | asignacionConstante);

		return errores;

	}
}

class CodDesigIden implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		TablaSimbolos ts = (TablaSimbolos) args[1].valor();
		int dir = ts.getDir((String) args[0].valor());
		String nivel = ts.dameNivel((String) args[0].valor());
		String clase = ts.dameClase((String) args[0].valor());
		ArrayList<String> cod = Funciones.creaCod();

		if (nivel.equals("global"))
			cod.add("apila(" + dir + ")");
		else if (nivel.equals("local")) {
			cod.add("apila(" + dir + ")");
			cod.add("apila_dir(1)");
			cod.add("suma");
			if (clase.equals("pvar"))
				cod.add("apila_ind");
		}

		return cod;
	}
}

class EtqDesigIden implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		TablaSimbolos ts = (TablaSimbolos) args[2].valor();
		int etq = (int) args[0].valor();
		String nivel = ts.dameNivel((String) args[1].valor());
		String clase = ts.dameClase((String) args[1].valor());

		if (nivel.equals("global"))
			etq += 1;
		else if (nivel.equals("local")) {
			etq += 3;
			if (clase.equals("pvar"))
				etq += 1;
		}

		return etq;
	}
}

class CreaErroresDesigIden implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		boolean noExisteId = !((TablaSimbolos) args[1].valor())
				.existeId((String) args[0].valor());

		ArrayList<Boolean> errores = Funciones.creaErrores();

		errores.set(1, errores.get(1) | noExisteId);

		return errores;
	}
}

class EtqInstIn implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		int etq = (int) args[0].valor() + 2;

		return etq;
	}
}

class CodInstIn implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = Funciones.creaCod();
		cod.addAll((ArrayList<String>) args[0].valor());
		Tipo tipo = (Tipo) args[1].valor();
		TablaSimbolos ts = (TablaSimbolos) args[2].valor();

		while (tipo.getTipo().equals("ref"))
			tipo = ts.getTipo(((TipoIdent) tipo).getId());

		cod.add("read(" + tipo.getTipo() + ")");
		cod.add("desapila_ind");

		return cod;
	}
}

class TipoResult2 implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		Tipo tipo1 = (Tipo) args[1].valor();
		Tipo tipo2 = (Tipo) args[2].valor();
		ArrayList<String> op = (ArrayList<String>) args[0].valor();

		Tipo tipoResultante = Funciones.consultarTipoResultante(tipo1.getTipo()
				+ tipo2.getTipo() + (String) op.get(0));

		return tipoResultante;
	}
}

class TipoResult1 implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> op = (ArrayList<String>) args[0].valor();
		Tipo tipo = (Tipo) args[1].valor();

		Tipo tipoResultante = Funciones.consultarTipoResultante(tipo.getTipo()
				+ (String) op.get(0));

		return tipoResultante;
	}
}

class CodExp implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = Funciones.creaCod();
		boolean esdesig1 = (boolean) args[3].valor();
		boolean esdesig2 = (boolean) args[4].valor();

		cod.addAll((ArrayList<String>) args[0].valor());
		if (esdesig1)
			cod.add("apila_ind");

		cod.addAll((ArrayList<String>) args[1].valor());
		if (esdesig2)
			cod.add("apila_ind");

		cod.addAll((ArrayList<String>) args[2].valor());

		return cod;
	}
}

class CodExpNivel4 implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = Funciones.creaCod();
		boolean esdesig1 = (boolean) args[2].valor();
		Tipo ti = (Tipo) args[3].valor();

		cod.addAll((ArrayList<String>) args[0].valor());
		if (esdesig1)
			cod.add("apila_ind");

		ArrayList<String> op = (ArrayList<String>) args[1].valor();

		if (op.get(0).equals(("(nat)")) || op.get(0).equals(("(int)"))
				|| op.get(0).equals(("(float)"))
				|| op.get(0).equals(("(char)")))
			cod.add("casting(" + ti.getTipo() + ")");

		else
			cod.addAll((ArrayList<String>) args[1].valor());

		return cod;
	}
}

class SumaEtqExp implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		int etq = (int) args[0].valor() + 1;

		if ((boolean) args[1].valor())
			etq += 1;
		if ((boolean) args[2].valor())
			etq += 1;

		return etq;
	}
}

class Irf_irv_OpOr implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String op = ((ArrayList<String>) args[0].valor()).get(0);
		int irv_irf = (int) args[1].valor();
		int etq = (int) args[2].valor();
		boolean esDesig = (boolean) args[3].valor();

		if (esDesig)
			etq += 1;
		if (op.equals("or"))
			return irv_irf;
		else
			return etq;
	}
}

class Irf_irv_OpOrSuma2 implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String op = ((ArrayList<String>) args[0].valor()).get(0);
		int etq = (int) args[1].valor();
		boolean esDesig = (boolean) args[2].valor();

		if (esDesig)
			etq += 1;
		if (op.equals("or"))
			return etq + 2;
		else
			return etq;
	}
}

class Irf_irv_OpAnd implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String op = ((ArrayList<String>) args[0].valor()).get(0);
		int irv_irf = (int) args[1].valor();
		int etq = (int) args[2].valor();
		boolean esDesig = (boolean) args[3].valor();

		if (esDesig)
			etq += 1;
		if (op.equals("and"))
			return irv_irf;
		else
			return etq;

	}
}

class Irf_irv_OpAndSuma2 implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String op = ((ArrayList<String>) args[0].valor()).get(0);
		int etq = (int) args[1].valor();
		boolean esDesig = (boolean) args[2].valor();

		if (esDesig)
			etq += 1;
		if (op.equals("and"))
			return etq + 2;
		else
			return etq;
	}
}

class EtqhSuma3 implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		String op = ((ArrayList<String>) args[1].valor()).get(0);
		if (op.equals("or"))
			return (int) args[0].valor() + 3;
		else
			return (int) args[0].valor();

	}
}

class EtqhSuma3ExpNivel2 implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		String op = ((ArrayList<String>) args[1].valor()).get(0);
		if (op.equals("and"))
			return (int) args[0].valor() + 3;
		else
			return (int) args[0].valor();

	}
}

class EtqExpnivel1 implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> x = (ArrayList<String>) args[3].valor();
		String op = x.get(0);
		int etq = (int) args[0].valor();
		if (!op.equals("or"))
			etq++;

		if ((boolean) args[1].valor())
			etq += 1;
		if ((boolean) args[2].valor())
			etq += 1;

		return etq;
	}
}

class EtqExpnivel2 implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<String> x = (ArrayList<String>) args[0].valor();
		String op = x.get(0);
		int etq = (int) args[1].valor();
		if (!op.equals("and"))
			etq++;

		if ((boolean) args[2].valor())
			etq += 1;
		if ((boolean) args[3].valor())
			etq += 1;

		return etq;
	}
}

class CodExpnivel1 implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = ts.Funciones.creaCod();
		String op = ((ArrayList<String>) args[5].valor()).get(0);

		if (op.equals("or")) {
			cod.addAll((ArrayList<String>) args[0].valor());
			if ((boolean) args[3].valor())
				cod.add("apila_ind");
			cod.add("copia");
			cod.add("ir_v(" + (int) args[1].valor() + ")");
			cod.add("desapila");
			cod.addAll((ArrayList<String>) args[2].valor());
			if ((boolean) args[4].valor())
				cod.add("apila_ind");
		} else {
			cod.addAll((ArrayList<String>) args[0].valor());
			if ((boolean) args[3].valor())
				cod.add("apila_ind");
			cod.addAll((ArrayList<String>) args[2].valor());
			if ((boolean) args[4].valor())
				cod.add("apila_ind");
			if (op.equals("suma") || op.equals("resta"))
				cod.add(op + "(" + ((Tipo) args[6].valor()).getTipo() + ")");
			else
				cod.add(op);
		}
		return cod;
	}
}

class CodExpnivel2 implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = ts.Funciones.creaCod();
		String op = ((ArrayList<String>) args[0].valor()).get(0);
		if (op.equals("and")) {
			cod.addAll((ArrayList<String>) args[1].valor());
			if ((boolean) args[4].valor())
				cod.add("apila_ind");
			cod.add("copia");
			cod.add("ir_f(" + (int) args[2].valor() + ")");
			cod.add("desapila");
			cod.addAll((ArrayList<String>) args[3].valor());
			if ((boolean) args[5].valor())
				cod.add("apila_ind");
		} else {
			cod.addAll((ArrayList<String>) args[1].valor());
			if ((boolean) args[4].valor())
				cod.add("apila_ind");
			cod.addAll((ArrayList<String>) args[3].valor());
			if ((boolean) args[5].valor())
				cod.add("apila_ind");

			if (op.equals("multiplica") || op.equals("divide"))
				cod.add(op + "(" + ((Tipo) args[6].valor()).getTipo() + ")");
			cod.add(op);
		}
		return cod;
	}
}

class EtqDesignIndex implements SemFun {

	@Override
	public Object eval(Atributo... args) {
		int etq = (int) args[0].valor() + 3;
		boolean esDesigExp = (boolean) args[1].valor();

		if (esDesigExp)
			etq += 1;

		return etq;
	}
}

class TipoDesignIndex implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		Tipo desigTipo = (Tipo) args[0].valor();
		Tipo tamTipo = (Tipo) args[1].valor();
		TablaSimbolos ts = (TablaSimbolos) args[2].valor();

		if (desigTipo.getTipo().equals("errorTipo")
				|| tamTipo.getTipo().equals("errorTipo"))
			return new TipoError();

		while (desigTipo.getTipo().equals("ref"))
			desigTipo = ts.getTipo(((TipoIdent) desigTipo).getId());

		if (desigTipo.getTipo().equals("array")
				&& tamTipo.getTipo().equals("natural"))
			return ((TipoArray) desigTipo).getTipoBase();
		return new TipoError();
	}
}

class CodDesignIndex implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = Funciones.creaCod();
		Tipo tipo = ((Tipo) args[2].valor());
		TablaSimbolos ts = (TablaSimbolos) args[3].valor();
		boolean esDesigExp = (boolean) args[4].valor();

		if (tipo.getTipo().equals("errorTipo"))
			return cod;

		cod.addAll((ArrayList<String>) args[0].valor());
		cod.addAll((ArrayList<String>) args[1].valor());

		if (esDesigExp)
			cod.add("apila_ind");

		while (tipo.getTipo().equals("ref"))
			tipo = ts.getTipo(((TipoIdent) tipo).getId());

		int tamTipoBase = (((TipoArray) tipo).getTipoBase()).getTam();
		cod.add("apila(" + tamTipoBase + ")");

		cod.add("multiplica");
		cod.add("suma");

		return cod;
	}
}

class TipoDesignTupla implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		Tipo tipo = (Tipo) args[0].valor();
		int pos = Integer.parseInt((String) args[1].valor());
		TablaSimbolos ts = (TablaSimbolos) args[2].valor();

		while (tipo.getTipo().equals("ref"))
			tipo = ts.getTipo(((TipoIdent) tipo).getId());

		if (tipo.getTipo().equals("tupla"))
			return ((TipoTupla) tipo).getTipoTuplaPos(pos);
		else
			return new TipoError();
	}
}

class CodDesignTupla implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = Funciones.creaCod();
		Tipo tipo = (Tipo) args[1].valor();
		int pos = Integer.parseInt((String) args[2].valor());
		TablaSimbolos ts = (TablaSimbolos) args[3].valor();

		if (tipo.getTipo().equals("errorTipo"))
			return cod;

		cod.addAll((ArrayList<String>) args[0].valor());

		while (tipo.getTipo().equals("ref"))
			tipo = ts.getTipo(((TipoIdent) tipo).getId());

		int desp = 0;
		if (tipo.getTipo().equals("tupla"))
			desp = ((TipoTupla) tipo).getDespTuplaPos(pos);
		cod.add("apila(" + desp + ")");
		cod.add("suma");

		return cod;
	}
}

class ConcatErroresDesignTupla implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<Boolean> errores = Funciones
				.copiaErrores((ArrayList<Boolean>) args[0].valor());
		Tipo tipo = (Tipo) args[1].valor();

		int pos = Integer.parseInt((String) args[2].valor());
		;

		boolean accesoTupla = false;
		if (tipo.getTipo().equals("tupla"))
			accesoTupla = !((TipoTupla) tipo).existeCampo(pos);

		errores.set(6, errores.get(6) | accesoTupla);
		return errores;
	}
}

class CodInstOut implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = Funciones.copiaCod((ArrayList<String>) args[0]
				.valor());
		boolean esDesig = (boolean) args[1].valor();
		Tipo tipo = (Tipo) args[2].valor();
		TablaSimbolos ts = (TablaSimbolos) args[3].valor();

		while (tipo.getTipo().equals("ref"))
			tipo = ts.getTipo(((TipoIdent) tipo).getId());

		if (esDesig)
			cod.add("apila_ind");
		cod.add("write(" + tipo.getTipo() + ")");

		return cod;
	}
}

class SumaEtqOut implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		int etq = (int) args[0].valor() + 1;
		boolean esDesig = (boolean) args[1].valor();
		if (esDesig)
			etq += 1;

		return etq;
	}
}

class SumaEtqDesignMas1 implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		int etq = (int) args[0].valor() + 1;
		boolean esDesig = (boolean) args[1].valor();
		if (esDesig)
			etq += 1;

		return etq;
	}
}

class SumaEtqDesignMas1DesigExp implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		int etq = (int) args[0].valor() + 1;
		boolean esDesig = (boolean) args[1].valor();
		Tipo tipo = (Tipo) args[2].valor();
		if (tipo.getTam() == 1 && esDesig)
			etq += 1;

		return etq;
	}
}

class SumaEtqDesignador implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		int etq = (int) args[0].valor();
		boolean esDesig = (boolean) args[1].valor();
		if (esDesig)
			etq += 1;

		return etq;
	}
}


class TiposCompatibles implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		Tipo tipo1 = (Tipo) args[0].valor();
		Tipo tipo2 = (Tipo) args[1].valor();
		TablaSimbolos ts = (TablaSimbolos) args[2].valor();

		if (Funciones.tiposCompatibles(tipo1, tipo2, ts))
			return tipo1;
		else
			return new TipoError();
	}
}

class ErrDesignInst implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		boolean asignConstante = (((TablaSimbolos) args[0].valor())
				.esConst((String) args[1].valor()));
		ArrayList<Boolean> erroresDesig = (ArrayList<Boolean>) args[2].valor();
		ArrayList<Boolean> erroresExp = (ArrayList<Boolean>) args[3].valor();

		ArrayList<Boolean> errores = Funciones.unirErrores(erroresDesig,
				erroresExp);

		errores.set(4, errores.get(4) | asignConstante);

		return errores;
	}
}

class CodInstIf implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = Funciones.creaCod();
		ArrayList<String> codExp = Funciones
				.copiaCod((ArrayList<String>) args[0].valor());
		int etq = (int) args[1].valor();
		ArrayList<String> codInsts = Funciones
				.copiaCod((ArrayList<String>) args[2].valor());
		boolean esDesig = (boolean) args[3].valor();

		cod.addAll(codExp);
		if (esDesig)
			cod.add("apila_ind");
		cod.add("ir_f(" + etq + ")");
		cod.addAll(codInsts);

		return cod;
	}
}

class CodDesignInst implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = ts.Funciones.creaCod();
		Tipo tipo = (Tipo) args[3].valor();

		cod.addAll((ArrayList<String>) args[0].valor());
		cod.addAll((ArrayList<String>) args[1].valor());
		boolean esDesig = (boolean) args[2].valor();
		if (tipo.getTam() > 1) {
			cod.add("mueve(" + tipo.getTam() + ")");
		} else {
			if (esDesig)
				cod.add("apila_ind");
			cod.add("desapila_ind");
		}

		return cod;
	}
}

class CodInstIfElse implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = Funciones.creaCod();
		ArrayList<String> codExp = Funciones
				.copiaCod((ArrayList<String>) args[0].valor());
		int etqInsts0 = (int) args[1].valor();
		ArrayList<String> codInsts0 = Funciones
				.copiaCod((ArrayList<String>) args[2].valor());
		int etqInsts1 = (int) args[3].valor();
		ArrayList<String> codInsts1 = Funciones
				.copiaCod((ArrayList<String>) args[4].valor());
		boolean esDesig = (boolean) args[5].valor();

		cod.addAll(codExp);
		if (esDesig)
			cod.add("apila_ind");
		cod.add("ir_f(" + (etqInsts0 + 1) + ")");
		cod.addAll(codInsts0);
		cod.add("ir_a(" + etqInsts1 + ")");
		cod.addAll(codInsts1);

		return cod;
	}
}

class CodInstWhile implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = Funciones.creaCod();
		ArrayList<String> codExp = Funciones
				.copiaCod((ArrayList<String>) args[0].valor());
		int etqInsts = (int) args[1].valor();
		ArrayList<String> codInsts = Funciones
				.copiaCod((ArrayList<String>) args[2].valor());
		int etqhInst = (int) args[3].valor();
		boolean esDesig = (boolean) args[4].valor();

		cod.addAll(codExp);
		if (esDesig)
			cod.add("apila_ind");
		cod.add("ir_f(" + (etqInsts + 1) + ")");
		cod.addAll(codInsts);
		cod.add("ir_a(" + etqhInst + ")");

		return cod;
	}
}

class AsignTrueBool implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		return true;

	}
}

class AsignFalseBool implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		return false;

	}
}

class AddTSRemoveLocal implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		TablaSimbolos ts = Funciones.borrarTSL((TablaSimbolos) args[0].valor());
		return Funciones.creaTS(ts, (String) args[2].valor(),
				(String) args[3].valor(), (ArrayList<Boolean>) args[1].valor(),
				(Tipo) args[4].valor(), (int) args[5].valor());
	}
}

class CreaTSLocal implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		TablaSimbolos ts = (TablaSimbolos) args[0].valor();

		return Funciones.creaTSL(Funciones.borrarTSL(ts));
	}
}

class UnirErroresDecSubprogram implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String id = (String) args[2].valor();
		boolean duplicado = ((TablaSimbolos) args[3].valor())
				.existeIdGlobal(id);
		ArrayList<Boolean> errores = Funciones.unirErrores(
				(ArrayList<Boolean>) args[0].valor(),
				(ArrayList<Boolean>) args[1].valor());
		return Funciones.unirErrores(errores, duplicado, 0);
	}
}

class CrearProc implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<ParamProc> lista = (ArrayList<ParamProc>) args[0].valor();
		String id = (String) args[1].valor();
		Tipo tipoParam = (Tipo) args[2].valor();
		Tipo tipoCuerpoSub = (Tipo) args[3].valor();

		return Funciones.creaProc(lista, id, tipoParam, tipoCuerpoSub);
	}
}

class CopiaLista implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<ParamProc> lista = new ArrayList<ParamProc>();
		lista.addAll((ArrayList<ParamProc>) args[0].valor());

		return lista;
	}
}

class CrearListaVacia implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		return new ArrayList<ParamProc>();
	}
}

class ClasePVar implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return "pvar";
	}
}

class ModoValor implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return "valor";
	}
}

class ModoVar implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return "var";
	}
}

class UnirErroresParamsFSub implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		String id = (String) args[3].valor();
		boolean duplicado = ((TablaSimbolos) args[2].valor())
				.existeIdSoloLocal(id);
		ArrayList<Boolean> errores = Funciones.unirErrores(
				(ArrayList<Boolean>) args[0].valor(),
				(ArrayList<Boolean>) args[1].valor());
		return Funciones.unirErrores(errores, duplicado, 0);
	}
}

class AddCampoProc implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<ParamProc> lista = (ArrayList<ParamProc>) args[0].valor();
		String id = (String) args[1].valor();
		String modo = (String) args[2].valor();
		Tipo tipo = (Tipo) args[3].valor();
		int desp = (int) args[4].valor();
		int dir = (int) args[5].valor();

		ParamProc elem = new ParamProc(id, modo, tipo, desp);

		lista.add(elem);

		return lista;
	}
}

class AddCampoProcCreaLista implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		ArrayList<ParamProc> lista = new ArrayList<ParamProc>();
		String id = (String) args[0].valor();
		String modo = (String) args[1].valor();
		Tipo tipo = (Tipo) args[2].valor();

		ParamProc elem = new ParamProc(id, modo, tipo, 0);

		lista.add(elem);

		return lista;
	}
}

class AnadirTSDir0 implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		return Funciones
				.creaTS((TablaSimbolos) args[0].valor(),
						(String) args[2].valor(), (String) args[3].valor(),
						(ArrayList<Boolean>) args[1].valor(),
						(Tipo) args[4].valor(), 0);
	}
}

class SumaDespConTamTipoProc implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		int desp = (int) args[0].valor();
		Tipo tipo = ((Tipo) args[1].valor());
		String modo = ((String) args[2].valor());
		if (modo.equals("var"))
			return desp + 1;
		else
			return desp + tipo.getTam();
	}
}

class SumaPrimerDespConTamTipoProc implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		Tipo tipo = ((Tipo) args[0].valor());
		String modo = ((String) args[1].valor());
		if (modo.equals("var"))
			return 1;
		else
			return tipo.getTam();
	}
}

class CodCuerpoSub implements SemFun {
	@Override
	public Object eval(Atributo... args) {
	

		ArrayList<String> cod = Funciones.creaCod();
		ArrayList<String> codI = (ArrayList<String>) args[0].valor();
		int tamVariables = (int) args[1].valor(); 
		cod.addAll(Funciones.crearPrologo(tamVariables));
		cod.addAll(codI);
		cod.addAll(Funciones.crearEpilogo(tamVariables));
		cod.add("ir_ind");

		return cod;
	}
}

class ParamsHeredado implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		TablaSimbolos ts = (TablaSimbolos) args[0].valor();
		return ((TipoProc) ts.getTipo((String) args[1].valor())).getCampos();
	}

}

class CopiaErroresCall implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		boolean noexisteId = !((TablaSimbolos) args[1].valor())
				.existeId((String) args[2].valor());
		boolean parametrosErroneo = false;
		int numeroParametros = (int) args[3].valor();
		int parametrosProc = ((TipoProc) ((TablaSimbolos) args[1].valor())
				.getTipo((String) args[2].valor())).getCampos().size();
		parametrosErroneo = numeroParametros != parametrosProc;
		ArrayList<Boolean> errores = (ArrayList<Boolean>) args[0].valor();
		errores.set(1, errores.get(1) | noexisteId);
		errores.set(7, errores.get(7) | parametrosErroneo);
		return errores;
	}
}

class CodCall implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> codigo = new ArrayList<String>();
		int dir = (int) args[0].valor();
		codigo.addAll(Funciones.cod_dirRetorno(dir));
		int dirSub = ((TablaSimbolos) args[3].valor()).getDir((String) args[2]
				.valor());

		codigo.addAll((ArrayList<String>) args[1].valor());
		codigo.add("ir_a(" + dirSub + ")");
		return codigo;
	}
}

class CodigoParamsFCall0 implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> cod = Funciones.creaCod();
		ArrayList<String> codParametrosFunC = (ArrayList<String>) args[0]
				.valor();

		cod.add("apila_dir(0)");
		cod.add("apila(3)");
		cod.add("suma");

		cod.addAll(codParametrosFunC);
		cod.add("desapila");

		return cod;
	}

}

class ErrCall implements SemFun {
	public Object eval(Atributo... args) {
		boolean noexisteId = false;

		ArrayList<ParamProc> cont = (ArrayList<ParamProc>) args[3].valor();
		String id = (String) args[2].valor();
		Iterator<ParamProc> it = cont.iterator();
		while (it.hasNext() && !noexisteId) {
			ParamProc c = it.next();
			if (id.equals(c.getId()))
				noexisteId = true;
		}

		ArrayList<Boolean> errores = (ArrayList<Boolean>) args[0].valor();
		errores.set(1, errores.get(1) | !noexisteId);
		return errores;
	}
}

class CodCallId implements SemFun {
	@Override
	public Object eval(Atributo... args) {

		ArrayList<String> codigo = new ArrayList<String>();
		codigo.add("copia");
		String id = (String) args[3].valor();
		ArrayList<ParamProc> contenido = (ArrayList<ParamProc>) args[2].valor();
		String modo = "";
		int desp = 0;
		int tam = 0;
		Iterator<ParamProc> it = contenido.iterator();
		while (it.hasNext()) {
			ParamProc c = it.next();
			if (id.equals(c.getId())) {
				modo = c.getModo();
				desp = c.getDesp();
				tam = c.getTipo().getTam();
			}
		}
		codigo.add("apila(" + desp + ")");
		codigo.add("suma");
		ArrayList<String> exp = (ArrayList<String>) args[0].valor();
		codigo.addAll(exp);
		boolean esDesig = (boolean) args[1].valor();
		if (!esDesig) {
			if (modo.equals("valor")) {
				codigo.add("desapila_ind");
			} else if (modo.equals("var")) {
			}
		} else {
			if (modo.equals("valor")) {
				codigo.add("mueve(" + tam + ")");
			} else if (modo.equals("var")) {
				codigo.add("desapila_ind");
			}
		}

		return codigo;
	}
}

class EtqCall implements SemFun {
	public Object eval(Atributo... args) {
		int etq = (int) args[0].valor();
		return etq + 3;
	}
}

class TipoCompatibleCall implements SemFun {
	@Override
	public Object eval(Atributo... args) {
		TablaSimbolos ts = (TablaSimbolos) args[3].valor();
		Tipo ti = (Tipo) args[0].valor();
		ArrayList<ParamProc> contenido = (ArrayList<ParamProc>) args[1].valor();
		String id = (String) args[2].valor();

		Tipo param = new TipoError();
		Iterator<ParamProc> it = contenido.iterator();
		while (it.hasNext()) {
			ParamProc c = it.next();
			if (id.equals(c.getId()))
				param = c.getTipo();
		}

		if (param.getTipo().equals("errorTipo"))
			return new TipoError();

		if (Funciones.tiposCompatibles(param, ti, ts))
			return param;
		else
			return new TipoError();

	}
}

public class EAtribucion extends Atribucion {

	private static SemFun asignacionP = new AsignacionP();
	private static SemFun asignacionL = new AsignacionL();
	private static SemFun asignacion0 = new Asignacion0();
	private static SemFun asignacion1 = new Asignacion1();
	private static SemFun asignacion2 = new Asignacion2();
	private static SemFun asignacion3 = new Asignacion3();
	private static SemFun asignacionmenos = new AsignacionMenos();
	private static SemFun asignacion = new Asignacion();
	private static SemFun AsignTrue = new AsignTrue();
	private static SemFun asignacionFalse = new AsignacionFalse();
	private static SemFun creaNatural = new CreaNatural();
	private static SemFun creaInt = new CreaInt();
	private static SemFun creaFloat = new CreaFloat();
	private static SemFun creaChar = new CreaChar();
	private static SemFun creaBool = new CreaBool();
	private static SemFun claseConst = new ClaseConst();
	private static SemFun codVacio = new CodVacio();
	private static SemFun creaErrores = new CreaErrores();
	private static SemFun creaTs = new CreaTs();
	private static SemFun asignacionSuma1 = new AsignacionSuma1();
	private static SemFun asignacionSuma2 = new AsignacionSuma2();
	private static SemFun asignacionSuma3 = new AsignacionSuma3();
	private static SemFun asignacionSuma4 = new AsignacionSuma4();
	private static SemFun asignacionSuma5 = new AsignacionSuma5();
	private static SemFun asignacionSuma13 = new AsignacionSuma13();
	private static SemFun asignacionSuma14 = new AsignacionSuma14();
	private static SemFun apilaInicializaConst = new AsignCodConst();
	private static SemFun asignacionTipoConsante = new IniciaTipoConst();
	private static SemFun AsignCodDecConst = new AsignCodDecConst();
	private static SemFun AsignTSDecConsts = new AsignTSDecConsts();
	private static SemFun unirDosTipos = new UnirDosTipos();
	private static SemFun unirTresTipos = new UnirTresTipos();
	private static SemFun unirCuatroTipos = new UnirCuatroTipos();
	private static SemFun unirCincoTipos = new UnirCincoTipos();
	private static SemFun copiaErroresOrDuplicado = new CopiaErroresOrDuplicado();
	private static SemFun unirErroresOrDuplicado = new UnirErroresOrDuplicado();
	private static SemFun sumaDirConTam = new SumaDirConTam();
	private static SemFun anadirTS = new AnadirTS();
	private static SemFun anadirTSTipo = new AnadirTSTipo();
	private static SemFun copiaErrores = new CopiaErrores();
	private static SemFun creaTipo = new CreaTipo();
	private static SemFun copiaCodigo = new CopiaCodigo();
	private static SemFun claseVar = new ClaseVar();
	private static SemFun claseTipo = new ClaseTipo();
	private static SemFun ClaseSubprogram = new ClaseSubprogram();

	private static SemFun concatenaDosCod = new ConcatenaDosCod();
	private static SemFun Concat2CodDesapila = new Concat2CodDesapila();
	private static SemFun creaCodMen = new CreaCodMen();
	private static SemFun creaCodMay = new CreaCodMay();
	private static SemFun creaCodMenIgual = new CreaCodMenIgual();
	private static SemFun creaCodMayIgual = new CreaCodMayIgual();
	private static SemFun creaCodIgual = new CreaCodIgual();
	private static SemFun creaCodNoIgual = new CreaCodNoIgual();
	private static SemFun creaCodMas = new CreaCodMas();
	private static SemFun creaCodMenos = new CreaCodMenos();
	private static SemFun creaCodOr = new CreaCodOr();
	private static SemFun creaCodMul = new CreaCodMul();
	private static SemFun creaCodDiv = new CreaCodDiv();
	private static SemFun creaCodMod = new CreaCodMod();
	private static SemFun creaCodAnd = new CreaCodAnd();
	private static SemFun CreaCodDespDerecha = new CreaCodDespDerecha();
	private static SemFun creaCodDespIzq = new CreaCodDespIzq();
	private static SemFun creaCodMenosUnario = new CreaCodMenosUnario();
	private static SemFun creaCodNot = new CreaCodNot();
	private static SemFun creaCodCastChar = new CreaCodCastChar();
	private static SemFun creaCodCastNat = new CreaCodCastNat();
	private static SemFun creaCodCastInt = new CreaCodCastInt();
	private static SemFun creaCodCastFloat = new CreaCodCastFloat();
	private static SemFun unirDosErrores = new UnirDosErrores();
	private static SemFun unirTresErrores = new UnirTresErrores();
	private static SemFun unirCuatroErrores = new UnirCuatroErrores();
	private static SemFun unirCincoErrores = new UnirCincoErrores();
	private static SemFun ConcatCodProg = new ConcatCodProg();
	private static SemFun ConcatCodInsts = new ConcatCodInsts();

	private static SemFun ConcatCodDecs = new ConcatCodDecs();
	private static SemFun tipoDeIdConTS = new TipoDeIdConTS();
	private static SemFun dameTipoDeIdConTS = new DameTipoDeIdConTS();
	private static SemFun CreaErroresTipoIdent = new CreaErroresTipoIdent();
	private static SemFun creaArray = new CreaArray();
	private static SemFun CreaArrayIdent = new CreaArrayIdent();
	private static SemFun CreaErroresTipoArrayIdent = new CreaErroresTipoArrayIdent();
	private static SemFun dameTamTipo = new DameTamTipo();
	private static SemFun primerCampoTupla = new PrimerCampoTupla();
	private static SemFun sumaDespConTamTipo = new SumaDespConTamTipo();
	private static SemFun AddCampoTupla = new AddCampoTupla();
	private static SemFun creaTuplaVacia = new CreaTuplaVacia();
	private static SemFun creaTupla = new CreaTupla();
	private static SemFun creaCodSwap1 = new CreaCodSwap1();
	private static SemFun creaCodSwap2 = new CreaCodSwap2();
	private static SemFun copiaErroresInstsIn = new CopiaErroresInstsIn();
	private static SemFun creaErroresDesigIden = new CreaErroresDesigIden();
	private static SemFun codDesigIden = new CodDesigIden();
	private static SemFun etqDesigIden = new EtqDesigIden();
	private static SemFun codInstIn = new CodInstIn();
	private static SemFun etqInstIn = new EtqInstIn();
	private static SemFun EtqDesignIndex = new EtqDesignIndex();
	private static SemFun TipoDesignIndex = new TipoDesignIndex();
	private static SemFun CodDesignIndex = new CodDesignIndex();
	private static SemFun TipoDesignTupla = new TipoDesignTupla();
	private static SemFun CodDesignTupla = new CodDesignTupla();
	private static SemFun ConcatErroresDesignTupla = new ConcatErroresDesignTupla();

	private static SemFun TipoResult2 = new TipoResult2();
	private static SemFun codExp = new CodExp();
	private static SemFun sumaEtqExp = new SumaEtqExp();
	private static SemFun irf_irv_Op = new Irf_irv_OpOr();
	private static SemFun irf_irv_OpSuma2 = new Irf_irv_OpOrSuma2();
	private static SemFun irf_irv_OpAnd = new Irf_irv_OpAnd();
	private static SemFun irf_irv_OpAndSuma2 = new Irf_irv_OpAndSuma2();
	private static SemFun etqhSuma3 = new EtqhSuma3();
	private static SemFun etqExpnivel1 = new EtqExpnivel1();
	private static SemFun codExpnivel1 = new CodExpnivel1();
	private static SemFun etqExpnivel2 = new EtqExpnivel2();
	private static SemFun etqhSuma3Expnivel2 = new EtqhSuma3ExpNivel2();
	private static SemFun codExpnivel2 = new CodExpnivel2();
	private static SemFun TipoResult1 = new TipoResult1();

	private static SemFun codExpnivel4 = new CodExpNivel4();
	private static SemFun codApilaValor = new CodApilaValor();
	private static SemFun CodApilaChar = new CodApilaChar();
	private static SemFun codApilafalse = new CodApilaFalse();
	private static SemFun codApilatrue = new CodApilaTrue();
	private static SemFun codInstOut = new CodInstOut();
	private static SemFun sumaEtqOut = new SumaEtqOut();
	private static SemFun SumaEtqDesignMas1 = new SumaEtqDesignMas1();
	private static SemFun sumaEtqDesignador = new SumaEtqDesignador();
	private static SemFun codInstIf = new CodInstIf();
	private static SemFun codInstIfElse = new CodInstIfElse();
	private static SemFun codInstWhile = new CodInstWhile();
	private static SemFun tiposCompatibles = new TiposCompatibles();
	private static SemFun ErrDesignInst = new ErrDesignInst();
	private static SemFun CodDesignInst = new CodDesignInst();
	private static SemFun AsignTrueBool = new AsignTrueBool();
	private static SemFun AsignFalseBool = new AsignFalseBool();

	private static SemFun AddTSRemoveLocal = new AddTSRemoveLocal();
	private static SemFun creaTSLocal = new CreaTSLocal();
	private static SemFun unirErroresDecSubprogram = new UnirErroresDecSubprogram();
	private static SemFun crearProc = new CrearProc();
	private static SemFun copiaLista = new CopiaLista();
	private static SemFun crearListaVacia = new CrearListaVacia();
	private static SemFun clasePVar = new ClasePVar();
	private static SemFun modoVar = new ModoVar();
	private static SemFun modoValor = new ModoValor();
	private static SemFun UnirErroresParamsFSub = new UnirErroresParamsFSub();
	private static SemFun AddCampoProc = new AddCampoProc();
	private static SemFun dirConTam = new DirConTam();
	private static SemFun anadirTSDir0 = new AnadirTSDir0();
	private static SemFun CodCuerpoSub = new CodCuerpoSub();
	private static SemFun sumaDespConTamTipoProc = new SumaDespConTamTipoProc();
	private static SemFun sumaPrimerDespConTamTipoProc = new SumaPrimerDespConTamTipoProc();
	private static SemFun AddCampoProcCreaLista = new AddCampoProcCreaLista();
	private static SemFun SumaEtqDesignMas1DesigExp = new SumaEtqDesignMas1DesigExp();
	private static SemFun CodigoParamsFCall0 = new CodigoParamsFCall0();
	private static SemFun paramsHeredado = new ParamsHeredado();
	private static SemFun copiaErroresCall = new CopiaErroresCall();
	private static SemFun codCall = new CodCall();
	private static SemFun errCall = new ErrCall();
	private static SemFun codCallId = new CodCallId();
	private static SemFun etqCall = new EtqCall();
	private static SemFun tipoCompatibleCall = new TipoCompatibleCall();

	public TAtributos programa1(String iden, TAtributos constantes,
			TAtributos tipos, TAtributos variables, TAtributos subprogramas,
			TAtributos instrucciones) {
		regla("Programa -> program : ident {SeccionDeclaraciones SeccionInstrucciones}");
		TAtributos prog = atributosPara("PROG", "cod", "ts", "err", "tipo",
				"etq", "dir");
		Atributo nombrePrograma = atributoLexicoPara("IDENTIFICADOR", "lex",
				iden);
		dependencias(tipos.a("tsh"), constantes.a("ts"));
		dependencias(variables.a("tsh"), tipos.a("ts"));
		dependencias(variables.a("dirh"), constantes.a("dir"));
		dependencias(subprogramas.a("tsh"), variables.a("ts"));
		dependencias(subprogramas.a("etqh"), constantes.a("etq"));
		dependencias(instrucciones.a("tsh"), subprogramas.a("ts"));
		dependencias(instrucciones.a("etqh"), subprogramas.a("etq"));
		dependencias(prog.a("ts"), subprogramas.a("ts"));
		dependencias(prog.a("err"), constantes.a("err"), tipos.a("err"),variables.a("err"), subprogramas.a("err"),instrucciones.a("err"));
		dependencias(prog.a("tipo"), constantes.a("tipo"), tipos.a("tipo"),variables.a("tipo"), subprogramas.a("tipo"),instrucciones.a("tipo"));
		dependencias(prog.a("cod"), constantes.a("cod"), subprogramas.a("cod"),variables.a("dir"), subprogramas.a("etq"),instrucciones.a("cod"), prog.a("err"), prog.a("tipo"));
		dependencias(prog.a("etq"), instrucciones.a("etq"));
		dependencias(prog.a("dir"), subprogramas.a("dir"));
		calculo(tipos.a("tsh"), asignacion);
		calculo(variables.a("dirh"), asignacion);
		calculo(variables.a("tsh"), asignacion);
		calculo(subprogramas.a("tsh"), asignacion);
		calculo(subprogramas.a("etqh"), asignacionSuma5);
		calculo(instrucciones.a("tsh"), asignacion);
		calculo(instrucciones.a("etqh"), asignacion);
		calculo(prog.a("ts"), asignacion);
		calculo(prog.a("err"), unirCincoErrores);
		calculo(prog.a("tipo"), unirCincoTipos);
		calculo(prog.a("cod"), ConcatCodProg);
		calculo(prog.a("etq"), asignacionSuma1);
		calculo(prog.a("dir"), asignacion);
		return prog;
	}

	public TAtributos declaraciones(TAtributos constantes, TAtributos tipos,
			TAtributos variables, TAtributos subprogramas) {
		regla("Declaraciones → Constantes Tipos Variables Subprogramas  ");

		TAtributos declaraciones = atributosPara("DECLARACIONES", "cod", "ts",
				"err", "etq", "tipo", "dir");

		dependencias(subprogramas.a("etqh"), constantes.a("etq"));
		dependencias(declaraciones.a("cod"), constantes.a("cod"),subprogramas.a("cod"), variables.a("dir"),subprogramas.a("etq"));
		dependencias(declaraciones.a("err"), constantes.a("err"),tipos.a("err"), variables.a("err"), subprogramas.a("err"));
		dependencias(declaraciones.a("ts"), subprogramas.a("ts"));
		dependencias(declaraciones.a("etq"), subprogramas.a("etq"));
		dependencias(declaraciones.a("tipo"), constantes.a("tipo"),tipos.a("tipo"), variables.a("tipo"), subprogramas.a("tipo"));

		calculo(declaraciones.a("cod"), ConcatCodDecs);
		calculo(declaraciones.a("err"), unirCuatroErrores);
		calculo(declaraciones.a("etq"), asignacion);
		calculo(declaraciones.a("tipo"), unirCuatroTipos);
		calculo(declaraciones.a("ts"), asignacion);

		return declaraciones;
	}

	public TAtributos defConstantes0(TAtributos decconsts) {
		regla("Constantes →  consts { DecConsts }");

		TAtributos constante1 = atributosPara("CONSTANTES", "cod", "err",
				"tipo", "dir", "etq", "ts");

		dependencias(constante1.a("cod"), decconsts.a("cod"),
				constante1.a("err"), constante1.a("tipo"));
		dependencias(constante1.a("err"), decconsts.a("err"));
		dependencias(constante1.a("tipo"), decconsts.a("tipo"));
		dependencias(constante1.a("dir"), decconsts.a("dir"));
		dependencias(constante1.a("etq"), decconsts.a("etq"));
		dependencias(constante1.a("ts"), decconsts.a("ts"));

		calculo(constante1.a("ts"), asignacion);
		calculo(constante1.a("err"), copiaErrores);
		calculo(constante1.a("tipo"), asignacion);
		calculo(constante1.a("dir"), asignacion);
		calculo(constante1.a("cod"), copiaCodigo);
		calculo(constante1.a("etq"), asignacion);

		return constante1;
	}

	public TAtributos defConstantes1() {
		regla("Constantes →  λ");

		TAtributos constante2 = atributosPara("CONSTANTES", "cod", "ts", "err",
				"tipo", "etq", "dir");

		calculo(constante2.a("ts"), creaTs);
		calculo(constante2.a("err"), creaErrores);
		calculo(constante2.a("tipo"), creaTipo);
		calculo(constante2.a("cod"), codVacio);
		calculo(constante2.a("etq"), asignacion0);
		calculo(constante2.a("dir"), asignacion2);
		return constante2;
	}

	public TAtributos decConsts0(TAtributos decconsts, TAtributos decconst) {
		regla("DecConsts →  DecConsts DecConst");

		TAtributos decconsts0 = atributosPara("DECCONSTS", "cod", "err",
				"tipo", "dir", "ts", "etq");

		dependencias(decconsts0.a("err"), decconsts.a("err"),decconsts.a("ts"), decconst.a("id"));
		dependencias(decconsts0.a("tipo"), decconsts.a("tipo"),decconst.a("tipo"));
		dependencias(decconsts0.a("dir"), decconsts.a("dir"));
		dependencias(decconsts0.a("ts"), decconsts.a("ts"),decconsts0.a("err"), decconst.a("id"), decconst.a("clase"),decconst.a("tipo"), decconsts.a("dir"));
		dependencias(decconsts0.a("cod"), decconsts.a("cod"),decconst.a("cod"), decconsts0.a("ts"), decconst.a("id"),decconsts.a("err"), decconst.a("tipo"));
		dependencias(decconsts0.a("etq"), decconsts.a("etq"));

		calculo(decconsts0.a("err"), copiaErroresOrDuplicado);
		calculo(decconsts0.a("tipo"), unirDosTipos);
		calculo(decconsts0.a("dir"), asignacionSuma1);
		calculo(decconsts0.a("ts"), anadirTS);
		calculo(decconsts0.a("cod"), Concat2CodDesapila);
		calculo(decconsts0.a("etq"), asignacionSuma2);
		return decconsts0;
	}

	public TAtributos decConsts1(TAtributos decconst) {
		regla("DecConsts →  DecConst");

		TAtributos decconsts = atributosPara("DECCONSTS", "cod", "err", "tipo",
				"dir", "ts", "etq");

		dependencias(decconsts.a("tipo"), decconst.a("tipo"));
		dependencias(decconsts.a("ts"), decconst.a("id"), decconst.a("clase"),
				decconst.a("tipo"));
		dependencias(decconsts.a("cod"), decconst.a("cod"), decconsts.a("ts"),
				decconst.a("id"), decconsts.a("err"), decconst.a("tipo"));

		calculo(decconsts.a("etq"), asignacion2);
		calculo(decconsts.a("err"), creaErrores);
		calculo(decconsts.a("tipo"), asignacion);
		calculo(decconsts.a("cod"), AsignCodDecConst);
		calculo(decconsts.a("dir"), asignacion3);
		calculo(decconsts.a("ts"), AsignTSDecConsts);
		return decconsts;
	}

	public TAtributos decConst0(TAtributos tipobasico, String iden,
			TAtributos valor) {
		regla("Consts -> const TipoBásico identificador = valor ");

		TAtributos decconst = atributosPara("DECCONST", "cod", "tipo", "clase",
				"id");
		Atributo astring = atributoLexicoPara("STRING", "lex", iden);

		dependencias(decconst.a("tipo"), tipobasico.a("tipo"), valor.a("valor"));
		dependencias(decconst.a("id"), astring);
		dependencias(decconst.a("cod"), tipobasico.a("tipo"), valor.a("valor"));

		calculo(decconst.a("id"), asignacion);
		calculo(decconst.a("clase"), claseConst);
		calculo(decconst.a("tipo"), asignacionTipoConsante);
		calculo(decconst.a("cod"), apilaInicializaConst);
		return decconst;
	}

	public TAtributos vchar(String valor2) {
		regla("VALORES → vchar ");

		TAtributos vchar = atributosPara("VALOR", "valor");
		Atributo astring = atributoLexicoPara("STRING", "lex", valor2);
		dependencias(vchar.a("valor"), astring);

		calculo(vchar.a("valor"), asignacion);
		return vchar;
	}

	public TAtributos vbooleanTrue() {
		regla("VALORES → true ");

		TAtributos vtrue = atributosPara("VALOR", "valor");
		calculo(vtrue.a("valor"), AsignTrue);

		return vtrue;
	}

	public TAtributos vbooleanFalse() {
		regla("VALORES → false ");

		TAtributos vfalse = atributosPara("VALOR", "valor");
     	calculo(vfalse.a("valor"), asignacionFalse);

		return vfalse;
	}

	public TAtributos vnat(String valor2) {
		regla("VALORES → false ");

		TAtributos vnat = atributosPara("VALOR", "valor");
		Atributo astring = atributoLexicoPara("STRING", "lex", valor2);
		dependencias(vnat.a("valor"), astring);

		calculo(vnat.a("valor"), asignacion);
		return vnat;
	}

	public TAtributos vfloat(String valor2) {
		regla("VALORES → false ");

		TAtributos vfloat = atributosPara("VALOR", "valor");
		Atributo astring = atributoLexicoPara("STRING", "lex", valor2);
		dependencias(vfloat.a("valor"), astring);

		calculo(vfloat.a("valor"), asignacion);
		return vfloat;
	}

	public TAtributos vint(String valor2) {
		regla("VALORES → - VNATURAL ");

		TAtributos vint = atributosPara("VALOR", "valor");
		Atributo astring = atributoLexicoPara("STRING", "lex", valor2);
		dependencias(vint.a("valor"), astring);

		calculo(vint.a("valor"), asignacionmenos);
		return vint;
	}

	public TAtributos vmenosfloat(String valor2) {
		regla("VALORES → + VNATURAL ");

		TAtributos vmenosfloat = atributosPara("VALOR", "valor");
		Atributo astring = atributoLexicoPara("STRING", "lex", valor2);
		dependencias(vmenosfloat.a("valor"), astring);

		calculo(vmenosfloat.a("valor"), asignacionmenos);
		return vmenosfloat;
	}

	public TAtributos tipos0(TAtributos dectipos) {
		regla("Tipos ->  tipos { DecTipos }");

		TAtributos tipos = atributosPara("TIPOSPROD", "tsh", "ts", "err",
				"tipo");

		dependencias(dectipos.a("tsh"), tipos.a("tsh"));

		dependencias(tipos.a("ts"), dectipos.a("ts"));
		dependencias(tipos.a("err"), dectipos.a("err"));
		dependencias(tipos.a("tipo"), dectipos.a("tipo"));

		calculo(dectipos.a("tsh"), asignacion);
		calculo(tipos.a("ts"), asignacion);
		calculo(tipos.a("err"), copiaErrores);
		calculo(tipos.a("tipo"), asignacion);

		return tipos;
	}

	public TAtributos tipos1() {
		regla("Tipos ->  lamda");

		TAtributos tipos = atributosPara("TIPOSPROD", "tsh", "ts", "err",
				"tipo");

		dependencias(tipos.a("ts"), tipos.a("tsh"));

		calculo(tipos.a("ts"), asignacion);
		calculo(tipos.a("err"), creaErrores);
		calculo(tipos.a("tipo"), creaTipo);

		return tipos;
	}

	public TAtributos decTipos0(TAtributos dectipos1, TAtributos dectipo) {
		regla("DecTipos ->  DecTipos ; DecTipo");

		TAtributos dectipos0 = atributosPara("DECTIPOS", "tsh", "ts", "err",
				"tipo");

		dependencias(dectipos1.a("tsh"), dectipos0.a("tsh"));
		dependencias(dectipo.a("tsh"), dectipos1.a("ts"));
		dependencias(dectipos0.a("err"), dectipos1.a("err"), dectipo.a("err"),dectipos1.a("ts"), dectipo.a("id"));
		dependencias(dectipos0.a("tipo"), dectipos1.a("tipo"),dectipo.a("tipo"));
		dependencias(dectipos0.a("ts"), dectipos1.a("ts"), dectipos0.a("err"),dectipo.a("id"), dectipo.a("clase"), dectipo.a("tipo"));

		calculo(dectipos1.a("tsh"), asignacion);
		calculo(dectipo.a("tsh"), asignacion);

		calculo(dectipos0.a("err"), unirErroresOrDuplicado);
		calculo(dectipos0.a("tipo"), unirDosTipos);
		calculo(dectipos0.a("ts"), anadirTSTipo);

		return dectipos0;
	}

	public TAtributos decTipos1(TAtributos dectipo) {
		regla("DecTipos → DecTipo");

		TAtributos dectipos = atributosPara("DECTIPOS", "tsh", "ts", "err",
				"tipo");

		dependencias(dectipo.a("tsh"), dectipos.a("tsh"));
		dependencias(dectipos.a("err"), dectipo.a("err"), dectipos.a("tsh"),dectipo.a("id"));
		dependencias(dectipos.a("tipo"), dectipo.a("tipo"));
		dependencias(dectipos.a("ts"), dectipos.a("tsh"), dectipos.a("err"),dectipo.a("id"), dectipo.a("clase"), dectipo.a("tipo"));

		calculo(dectipo.a("tsh"), asignacion);
		calculo(dectipos.a("err"), copiaErroresOrDuplicado);
		calculo(dectipos.a("tipo"), asignacion);
		calculo(dectipos.a("ts"), anadirTSTipo);

		return dectipos;
	}

	public TAtributos decTipo0(TAtributos tipo, String iden) {
		regla("DecTipo → tipo Tipo identificador ");

		TAtributos dectipo = atributosPara("DECTIPO", "tsh", "id", "clase",
				"tipo", "err");
		Atributo identificador = atributoLexicoPara("STRING", "lex", iden);

		dependencias(tipo.a("tsh"), dectipo.a("tsh"));
		dependencias(dectipo.a("tipo"), tipo.a("tipo"));
		dependencias(dectipo.a("id"), identificador);
		dependencias(dectipo.a("err"), tipo.a("err"));

		calculo(tipo.a("tsh"), asignacion);
		calculo(dectipo.a("tipo"), asignacion);
		calculo(dectipo.a("id"), asignacion);
		calculo(dectipo.a("clase"), claseTipo);
		calculo(dectipo.a("err"), copiaErrores);

		return dectipo;
	}

	public TAtributos expTipo0(TAtributos tipobasico) {
		regla("Tipo→ tipoBasico ");

		TAtributos tipo = atributosPara("TIPOPROD", "tsh", "tipo", "err");

		dependencias(tipo.a("tipo"), tipobasico.a("tipo"));

		calculo(tipo.a("tipo"), asignacion);
		calculo(tipo.a("err"), creaErrores);

		return tipo;
	}

	public TAtributos expTipo1(String iden) {
		regla("Tipo→ identificador ");

		TAtributos tipo = atributosPara("TIPOPROD", "tsh", "tipo", "err");
		Atributo identificador = atributoLexicoPara("STRING", "lex", iden);

		dependencias(tipo.a("tipo"), identificador, tipo.a("tsh"));
		dependencias(tipo.a("err"), identificador, tipo.a("tsh"));

		calculo(tipo.a("tipo"), tipoDeIdConTS);
		calculo(tipo.a("err"), CreaErroresTipoIdent);

		return tipo;
	}

	public TAtributos expTipo2(TAtributos tipo1, String iden) {
		regla("Tipo→ Tipo [identificador] ");

		TAtributos tipo0 = atributosPara("TIPOPROD", "tsh", "tipo", "err");
		Atributo identificador = atributoLexicoPara("STRING", "lex", iden);

		dependencias(tipo1.a("tsh"), tipo0.a("tsh"));

		dependencias(tipo0.a("err"), tipo1.a("err"), identificador,
				tipo0.a("tsh"));
		dependencias(tipo0.a("tipo"), tipo0.a("tsh"), identificador,
				tipo1.a("tipo"));

		calculo(tipo1.a("tsh"), asignacion);
		calculo(tipo0.a("tipo"), CreaArrayIdent);
		calculo(tipo0.a("err"), CreaErroresTipoArrayIdent);

		return tipo0;
	}

	public TAtributos expTipo3(TAtributos tipo1, String vnat) {
		regla("Tipo→ Tipo [natural] ");

		TAtributos tipo0 = atributosPara("TIPOPROD", "tsh", "tipo", "err");
		Atributo vnatural = atributoLexicoPara("STRING", "lex", vnat);

		dependencias(tipo1.a("tsh"), tipo0.a("tsh"));

		dependencias(tipo0.a("tipo"), vnatural, tipo1.a("tipo"));
		dependencias(tipo0.a("err"), tipo1.a("err"));

		calculo(tipo1.a("tsh"), asignacion);
		calculo(tipo0.a("tipo"), creaArray);
		calculo(tipo0.a("err"), copiaErrores);

		return tipo0;
	}

	public TAtributos expTipo4(TAtributos rtupla) {
		regla("Tipo→ ( tupla ) ");

		TAtributos tipo = atributosPara("TIPOPROD", "tsh", "tipo", "err");

		dependencias(rtupla.a("tsh"), tipo.a("tsh"));

		dependencias(tipo.a("tipo"), rtupla.a("campos"), rtupla.a("err"),
				rtupla.a("tipo"));
		dependencias(tipo.a("err"), rtupla.a("err"));

		calculo(rtupla.a("tsh"), asignacion);
		calculo(tipo.a("tipo"), creaTupla);
		calculo(tipo.a("err"), copiaErrores);

		return tipo;
	}

	public TAtributos expTipo5() {
		regla("Tipo→ ( ) ");

		TAtributos tipo = atributosPara("TIPOPROD", "tsh", "tipo", "err");

		calculo(tipo.a("tipo"), creaTuplaVacia);
		calculo(tipo.a("err"), creaErrores);

		return tipo;
	}

	public TAtributos expTupla0(TAtributos rtupla1, TAtributos tipo) {
		regla("Tupla → Tupla, Tipo ");

		TAtributos rtupla0 = atributosPara("TIPOPROD", "tsh", "tipo", "campos",
				"desp", "err");

		dependencias(rtupla1.a("tsh"), rtupla0.a("tsh"));
		dependencias(tipo.a("tsh"), rtupla0.a("tsh"));

		dependencias(rtupla0.a("tipo"), rtupla1.a("tipo"), tipo.a("tipo"));
		dependencias(rtupla0.a("err"), rtupla1.a("err"), tipo.a("err"));
		dependencias(rtupla0.a("campos"), rtupla1.a("campos"), tipo.a("tipo"),
				rtupla1.a("desp"));
		dependencias(rtupla0.a("desp"), rtupla1.a("desp"), tipo.a("tipo"));

		calculo(rtupla1.a("tsh"), asignacion);
		calculo(tipo.a("tsh"), asignacion);

		calculo(rtupla0.a("tipo"), unirDosTipos);
		calculo(rtupla0.a("err"), unirDosErrores);
		calculo(rtupla0.a("desp"), sumaDespConTamTipo);
		calculo(rtupla0.a("campos"), AddCampoTupla);

		return rtupla0;
	}

	public TAtributos expTupla1(TAtributos tipo) {
		regla("Tupla -> Tipo ");

		TAtributos rtupla = atributosPara("TIPOPROD", "tsh", "tipo", "campos",
				"desp", "err");

		dependencias(tipo.a("tsh"), rtupla.a("tsh"));
		dependencias(rtupla.a("tipo"), tipo.a("tipo"));
		dependencias(rtupla.a("campos"), tipo.a("tipo"));
		dependencias(rtupla.a("desp"), tipo.a("tipo"));
		dependencias(rtupla.a("err"), tipo.a("err"));

		calculo(tipo.a("tsh"), asignacion);
		calculo(rtupla.a("tipo"), asignacion);
		calculo(rtupla.a("campos"), primerCampoTupla);
		calculo(rtupla.a("desp"), dameTamTipo);
		calculo(rtupla.a("err"), copiaErrores);

		return rtupla;
	}

	public TAtributos tBasicoNat() {
		regla("TipoBasico → natural ");

		TAtributos tipoBasico = atributosPara("TIPOBASICO", "tipo");

		calculo(tipoBasico.a("tipo"), creaNatural);
		return tipoBasico;
	}

	public TAtributos tBasicoInt() {
		regla("TipoBasico → int ");

		TAtributos tipoBasico = atributosPara("TIPOBASICO", "tipo");

		calculo(tipoBasico.a("tipo"), creaInt);
		return tipoBasico;
	}

	public TAtributos tBasicoChar() {
		regla("TipoBasico → char ");

		TAtributos tipoBasico = atributosPara("TIPOBASICO", "tipo");

		calculo(tipoBasico.a("tipo"), creaChar);
		return tipoBasico;
	}

	public TAtributos tBasicoFloat() {
		regla("TipoBasico → float ");

		TAtributos tipoBasico = atributosPara("TIPOBASICO", "tipo");

		calculo(tipoBasico.a("tipo"), creaFloat);
		return tipoBasico;
	}

	public TAtributos tBasicoBool() {
		regla("TipoBasico → bool ");

		TAtributos tipoBasico = atributosPara("TIPOBASICO", "tipo");

		calculo(tipoBasico.a("tipo"), creaBool);
		return tipoBasico;
	}

	public TAtributos expVars0(TAtributos decvars) {
		regla("Variables ->  vars { DecVars }");

		TAtributos variables1 = atributosPara("VARIABLES", "tsh", "dirh", "ts",
				"err", "tipo", "dir");
		dependencias(decvars.a("tsh"), variables1.a("tsh"));
		dependencias(decvars.a("dirh"), variables1.a("dirh"));

		dependencias(variables1.a("ts"), decvars.a("ts"));
		dependencias(variables1.a("err"), decvars.a("err"));
		dependencias(variables1.a("tipo"), decvars.a("tipo"));
		dependencias(variables1.a("dir"), decvars.a("dir"));

		calculo(decvars.a("tsh"), asignacion);
		calculo(decvars.a("dirh"), asignacion);

		calculo(variables1.a("ts"), asignacion);
		calculo(variables1.a("err"), copiaErrores);
		calculo(variables1.a("tipo"), asignacion);
		calculo(variables1.a("dir"), asignacion);

		return variables1;
	}

	public TAtributos expVars1() {
		regla("Variables ->  lambda");

		TAtributos variables2 = atributosPara("VARIABLES", "tsh", "dirh", "ts",
				"err", "tipo", "dir");

		dependencias(variables2.a("ts"), variables2.a("tsh"));
		dependencias(variables2.a("dir"), variables2.a("dirh"));

		calculo(variables2.a("ts"), asignacion);
		calculo(variables2.a("err"), creaErrores);
		calculo(variables2.a("tipo"), creaTipo);
		calculo(variables2.a("dir"), asignacion);

		return variables2;
	}

	public TAtributos decVars0(TAtributos decvars1, TAtributos decvar) {
		regla("DecVars ->  DecVars ; DecVar");

		TAtributos decvars0 = atributosPara("DECVARS", "tsh", "dirh", "err",
				"tipo", "dir", "ts");

		dependencias(decvars1.a("dirh"), decvars0.a("dirh"));
		dependencias(decvar.a("tsh"), decvars0.a("tsh"));
		dependencias(decvars1.a("tsh"), decvars0.a("tsh"));
		dependencias(decvars0.a("err"), decvars1.a("err"), decvar.a("err"),decvars1.a("ts"), decvar.a("id"));
		dependencias(decvars0.a("tipo"), decvars1.a("tipo"), decvar.a("tipo"));
		dependencias(decvars0.a("dir"), decvars1.a("dir"), decvar.a("tipo"),decvar.a("clase"));
		dependencias(decvars0.a("ts"), decvars1.a("ts"), decvars0.a("err"),decvar.a("id"), decvar.a("clase"), decvar.a("tipo"),decvars1.a("dir"));
		
		calculo(decvars1.a("dirh"), asignacion);
		calculo(decvar.a("tsh"), asignacion);
		calculo(decvars1.a("tsh"), asignacion);
		calculo(decvars0.a("err"), unirErroresOrDuplicado);
		calculo(decvars0.a("tipo"), unirDosTipos);
		calculo(decvars0.a("dir"), sumaDirConTam);
		calculo(decvars0.a("ts"), anadirTS);
		return decvars0;
	}

	public TAtributos decVars1(TAtributos decvar) {
		regla("DecVars → DecVar");

		TAtributos decvars = atributosPara("DECVARS", "tsh", "dirh", "err",
				"tipo", "dir", "ts");

		dependencias(decvar.a("tsh"), decvars.a("tsh"));

		dependencias(decvars.a("err"), decvar.a("err"), decvars.a("tsh"),
				decvar.a("id"));
		dependencias(decvars.a("tipo"), decvar.a("tipo"));
		dependencias(decvars.a("dir"), decvars.a("dirh"), decvar.a("tipo"),
				decvar.a("clase"));
		dependencias(decvars.a("ts"), decvars.a("tsh"), decvars.a("err"),
				decvar.a("id"), decvar.a("clase"), decvar.a("tipo"),
				decvars.a("dirh"));

		calculo(decvar.a("tsh"), asignacion);

		calculo(decvars.a("err"), copiaErroresOrDuplicado);
		calculo(decvars.a("tipo"), asignacion);
		calculo(decvars.a("dir"), sumaDirConTam);
		calculo(decvars.a("ts"), anadirTS);
		return decvars;
	}

	public TAtributos decVar0(TAtributos tipo, String iden) {
		regla("DecVar → var Tipo identificador ");

		TAtributos decvar = atributosPara("DECVAR", "tsh", "id", "clase",
				"tipo", "err");
		Atributo identificador = atributoLexicoPara("STRING", "lex", iden);

		dependencias(tipo.a("tsh"), decvar.a("tsh"));
		dependencias(decvar.a("id"), identificador);
		dependencias(decvar.a("tipo"), tipo.a("tipo"));
		dependencias(decvar.a("err"), tipo.a("err"));

		calculo(tipo.a("tsh"), asignacion);
		calculo(decvar.a("id"), asignacion);
		calculo(decvar.a("clase"), claseVar);
		calculo(decvar.a("tipo"), asignacion);
		calculo(decvar.a("err"), copiaErrores);

		return decvar;
	}

	/********************* SUBPROGRAMAS ***************************************/

	public TAtributos expSubprogramas0(TAtributos decssubprograms) {
		regla("Subprogramas -> subprograms { DecsSubprogramas }");

		TAtributos subprograms = atributosPara("SUBPROGRAMS", "tsh", "etqh",
				"ts", "etq", "cod", "err", "tipo");

		dependencias(decssubprograms.a("tsh"), subprograms.a("tsh"));
		dependencias(decssubprograms.a("etqh"), subprograms.a("etqh"));
		dependencias(subprograms.a("etq"), decssubprograms.a("etq"));
		dependencias(subprograms.a("ts"), decssubprograms.a("ts"));
		dependencias(subprograms.a("err"), decssubprograms.a("err"));
		dependencias(subprograms.a("tipo"), decssubprograms.a("tipo"));
		dependencias(subprograms.a("cod"), decssubprograms.a("cod"),subprograms.a("err"), subprograms.a("tipo"));

		calculo(decssubprograms.a("tsh"), asignacion);
		calculo(decssubprograms.a("etqh"), asignacion);
		calculo(subprograms.a("etq"), asignacion);
		calculo(subprograms.a("ts"), asignacion);
		calculo(subprograms.a("err"), copiaErrores);
		calculo(subprograms.a("tipo"), asignacion);
		calculo(subprograms.a("cod"), copiaCodigo);

		return subprograms;
	}

	public TAtributos expSubprogramas1() {
		regla("Subprograms -> lambda ");

		TAtributos subprograms = atributosPara("SUBPROGRAMAS", "tsh", "etqh",
				"etq", "cod", "ts", "err", "tipo");

		dependencias(subprograms.a("etq"), subprograms.a("etqh"));
		dependencias(subprograms.a("ts"), subprograms.a("tsh"));

		calculo(subprograms.a("etq"), asignacion);
		calculo(subprograms.a("ts"), asignacionL);
		calculo(subprograms.a("cod"), codVacio);
		calculo(subprograms.a("err"), creaErrores);
		calculo(subprograms.a("tipo"), creaTipo);

		return subprograms;
	}

	public TAtributos decSubprogramas0(TAtributos decsubprograms1,
			TAtributos decsubprogram) {
		regla("DecSubprograms -> DecSubprograms ; DecSubprogram ");

		TAtributos decsubprograms0 = atributosPara("DECSUBPROGRAMS", "tsh",
				"etqh", "etq", "cod", "ts", "err", "tipo");

		dependencias(decsubprograms1.a("tsh"), decsubprograms0.a("tsh"));
		dependencias(decsubprogram.a("tsh"), decsubprograms1.a("ts"));
		dependencias(decsubprograms1.a("etqh"), decsubprograms0.a("etqh"));
		dependencias(decsubprogram.a("etqh"), decsubprograms1.a("etq"));
		dependencias(decsubprograms0.a("etq"), decsubprogram.a("etq"));
		dependencias(decsubprograms0.a("cod"), decsubprograms1.a("cod"),
				decsubprogram.a("cod"));
		dependencias(decsubprograms0.a("err"), decsubprograms1.a("err"),
				decsubprogram.a("err"));
		dependencias(decsubprograms0.a("ts"), decsubprograms1.a("ts"),
				decsubprograms0.a("err"), decsubprogram.a("id"),
				decsubprogram.a("clase"), decsubprogram.a("tipo"),
				decsubprograms1.a("etq"));
		dependencias(decsubprograms0.a("tipo"), decsubprograms1.a("tipo"),
				decsubprogram.a("tipo"));
		calculo(decsubprograms1.a("tsh"), creaTSLocal);
		calculo(decsubprogram.a("tsh"), creaTSLocal);
		calculo(decsubprograms1.a("etqh"), asignacion);
		calculo(decsubprogram.a("etqh"), asignacion);
		calculo(decsubprograms0.a("etq"), asignacion);
		calculo(decsubprograms0.a("cod"), concatenaDosCod);
		calculo(decsubprograms0.a("err"), unirDosErrores);
		calculo(decsubprograms0.a("ts"), AddTSRemoveLocal);
		calculo(decsubprograms0.a("tipo"), unirDosTipos);
		return decsubprograms0;
	}

	public TAtributos decSubprogramas1(TAtributos decsubprogram) {
		regla("DecSubprograms -> DecSubprogram ");

		TAtributos decsubprograms = atributosPara("DECSUBPROGRAMS", "tsh",
				"etqh", "etq", "cod", "ts", "err", "tipo");

		dependencias(decsubprogram.a("tsh"), decsubprograms.a("tsh"));
		dependencias(decsubprogram.a("etqh"), decsubprograms.a("etqh"));

		dependencias(decsubprograms.a("etq"), decsubprogram.a("etq"));
		dependencias(decsubprograms.a("err"), decsubprogram.a("err"));
		dependencias(decsubprograms.a("tipo"), decsubprogram.a("tipo"));
		dependencias(decsubprograms.a("ts"), decsubprograms.a("tsh"),
				decsubprograms.a("err"), decsubprogram.a("id"),
				decsubprogram.a("clase"), decsubprograms.a("tipo"),
				decsubprograms.a("etqh"));
		dependencias(decsubprograms.a("cod"), decsubprogram.a("cod"),
				decsubprograms.a("err"), decsubprograms.a("tipo"));

		calculo(decsubprogram.a("tsh"), creaTSLocal);
		calculo(decsubprogram.a("etqh"), asignacion);

		calculo(decsubprograms.a("etq"), asignacion);
		calculo(decsubprograms.a("err"), copiaErrores);

		calculo(decsubprograms.a("tipo"), asignacion);
		calculo(decsubprograms.a("ts"), AddTSRemoveLocal);

		calculo(decsubprograms.a("cod"), copiaCodigo);

		return decsubprograms;
	}

	public TAtributos subprograma0(String iden, TAtributos parametros,
			TAtributos cuerposub) {
		regla("DecSubprogram -> subprogram : id (PFs) { CS } ");

		TAtributos decsubprogram = atributosPara("DECSUBPROGRAM", "tsh",
				"etqh", "etq", "cod", "err", "clase", "id", "tipo");
		Atributo identificador = atributoLexicoPara("IDENTIFICADOR", "lex",
				iden);

		dependencias(parametros.a("tsh"), decsubprogram.a("tsh"));
		dependencias(cuerposub.a("dirh"), parametros.a("dir"));
		dependencias(cuerposub.a("tsh"), parametros.a("ts"));
		dependencias(cuerposub.a("etqh"), decsubprogram.a("etqh"));

		dependencias(decsubprogram.a("id"), identificador);
		dependencias(decsubprogram.a("err"), parametros.a("err"),
				cuerposub.a("err"), identificador, decsubprogram.a("tsh"));
		dependencias(decsubprogram.a("tipo"), parametros.a("lista"),
				identificador, parametros.a("tipo"), cuerposub.a("tipo"));
		dependencias(decsubprogram.a("etq"), cuerposub.a("etq"));
		dependencias(decsubprogram.a("cod"), cuerposub.a("cod"),
				decsubprogram.a("err"), decsubprogram.a("tipo"));

		calculo(parametros.a("tsh"), asignacion);
		calculo(cuerposub.a("dirh"), asignacion);
		calculo(cuerposub.a("tsh"), asignacion);
		calculo(cuerposub.a("etqh"), asignacion);

		calculo(decsubprogram.a("clase"), ClaseSubprogram);
		calculo(decsubprogram.a("id"), asignacion);
		calculo(decsubprogram.a("err"), unirErroresDecSubprogram);
		calculo(decsubprogram.a("tipo"), crearProc);
		calculo(decsubprogram.a("etq"), asignacion);
		calculo(decsubprogram.a("cod"), copiaCodigo);

		return decsubprogram;
	}

	public TAtributos paramsSub0(TAtributos params) {
		regla("PFs -> PF");

		TAtributos parametrosSub0 = atributosPara("PARAMETROSSUB", "tsh",
				"tipo", "ts", "err", "lista", "dir");

		dependencias(params.a("tsh"), parametrosSub0.a("tsh"));

		dependencias(parametrosSub0.a("dir"), params.a("dir"));
		dependencias(parametrosSub0.a("err"), params.a("err"));
		dependencias(parametrosSub0.a("tipo"), params.a("tipo"));
		dependencias(parametrosSub0.a("lista"), params.a("lista"));
		dependencias(parametrosSub0.a("ts"), params.a("ts"));

		calculo(params.a("tsh"), asignacion);

		calculo(parametrosSub0.a("dir"), asignacion);
		calculo(parametrosSub0.a("err"), copiaErrores);
		calculo(parametrosSub0.a("tipo"), asignacion);
		calculo(parametrosSub0.a("lista"), copiaLista);
		calculo(parametrosSub0.a("ts"), asignacion);
		return parametrosSub0;
	}

	public TAtributos paramsSub1() {
		regla("PFs -> lambda");

		TAtributos parametrosSub = atributosPara("PARAMETROSSUB", "tsh",
				"lista", "tipo", "ts", "err", "dir");

		dependencias(parametrosSub.a("ts"), parametrosSub.a("tsh"));

		calculo(parametrosSub.a("lista"), crearListaVacia);
		calculo(parametrosSub.a("ts"), asignacion);
		calculo(parametrosSub.a("err"), creaErrores);
		calculo(parametrosSub.a("dir"), asignacion0);
		calculo(parametrosSub.a("tipo"), creaTipo);

		return parametrosSub;
	}

	public TAtributos PFS0(TAtributos parametrosFSub1, TAtributos param) {
		regla("ParametrosFSub -> ParametrosFSub, ParametroFSub");

		TAtributos parametrosFSub0 = atributosPara("PARAMETROSFSUB", "tsh",
				"lista", "dir", "ts", "err", "tipo", "desp");

		dependencias(parametrosFSub1.a("tsh"), parametrosFSub0.a("tsh"));
		dependencias(param.a("tsh"), parametrosFSub1.a("ts"));

		dependencias(parametrosFSub0.a("err"), parametrosFSub1.a("err"),
				param.a("err"), parametrosFSub1.a("ts"), param.a("id"));
		dependencias(parametrosFSub0.a("ts"), parametrosFSub1.a("ts"),
				param.a("err"), param.a("id"), param.a("clase"),
				param.a("tipo"), parametrosFSub1.a("dir"));
		dependencias(parametrosFSub0.a("dir"), parametrosFSub1.a("dir"),
				param.a("tipo"), param.a("clase"));
		dependencias(parametrosFSub0.a("tipo"), parametrosFSub1.a("tipo"),
				param.a("tipo"));
		dependencias(parametrosFSub0.a("desp"), parametrosFSub1.a("desp"),
				param.a("tipo"), param.a("modo"));
		dependencias(parametrosFSub0.a("lista"), parametrosFSub1.a("lista"),
				param.a("id"), param.a("modo"), param.a("tipo"),
				parametrosFSub1.a("desp"), parametrosFSub1.a("dir"));

		calculo(parametrosFSub1.a("tsh"), asignacion);
		calculo(param.a("tsh"), asignacion);

		calculo(parametrosFSub0.a("err"), UnirErroresParamsFSub);
		calculo(parametrosFSub0.a("ts"), anadirTS);
		calculo(parametrosFSub0.a("dir"), sumaDirConTam);
		calculo(parametrosFSub0.a("tipo"), unirDosTipos);
		calculo(parametrosFSub0.a("desp"), sumaDespConTamTipoProc);
		calculo(parametrosFSub0.a("lista"), AddCampoProc);

		return parametrosFSub0;
	}

	public TAtributos PFS1(TAtributos parametroF) {
		regla("ParametrosFSub -> ParametroFSub");

		TAtributos parametrosFSub = atributosPara("PARAMETROSFSUB", "tsh",
				"lista", "dir", "ts", "err", "tipo", "desp");

		dependencias(parametroF.a("tsh"), parametrosFSub.a("tsh"));

		dependencias(parametrosFSub.a("err"), parametroF.a("err"));
		dependencias(parametrosFSub.a("ts"), parametrosFSub.a("tsh"),
				parametroF.a("err"), parametroF.a("id"), parametroF.a("clase"),
				parametroF.a("tipo"));
		dependencias(parametrosFSub.a("lista"), parametroF.a("id"),
				parametroF.a("modo"), parametroF.a("tipo"));
		dependencias(parametrosFSub.a("dir"), parametroF.a("tipo"),
				parametroF.a("clase"));
		dependencias(parametrosFSub.a("tipo"), parametroF.a("tipo"));
		dependencias(parametrosFSub.a("desp"), parametroF.a("tipo"),
				parametroF.a("modo"));

		calculo(parametroF.a("tsh"), asignacion);

		calculo(parametrosFSub.a("err"), copiaErrores);
		calculo(parametrosFSub.a("ts"), anadirTSDir0);
		calculo(parametrosFSub.a("lista"), AddCampoProcCreaLista);
		calculo(parametrosFSub.a("dir"), dirConTam);
		calculo(parametrosFSub.a("tipo"), asignacion);
		calculo(parametrosFSub.a("desp"), sumaPrimerDespConTamTipoProc);

		return parametrosFSub;
	}

	public TAtributos PF0(TAtributos tipo, String iden) {
		regla("ParametroFSub -> Tipo Identificador ");

		TAtributos parametroFSub = atributosPara("PARAMETROFSUB", "tsh", "id",
				"tipo", "clase", "modo", "err");
		Atributo identificador = atributoLexicoPara("IDENTIFICADOR", "lex",
				iden);

		dependencias(tipo.a("tsh"), parametroFSub.a("tsh"));

		dependencias(parametroFSub.a("id"), identificador);
		dependencias(parametroFSub.a("tipo"), tipo.a("tipo"));
		dependencias(parametroFSub.a("err"), tipo.a("err"));

		calculo(tipo.a("tsh"), asignacion);

		calculo(parametroFSub.a("id"), asignacion);
		calculo(parametroFSub.a("clase"), claseVar);
		calculo(parametroFSub.a("modo"), modoValor);
		calculo(parametroFSub.a("err"), copiaErrores);
		calculo(parametroFSub.a("tipo"), asignacion);

		return parametroFSub;
	}

	public TAtributos PF1(TAtributos tipo, String iden) {
		regla("ParametrosF -> Tipo * Identificador");

		TAtributos parametroFSub = atributosPara("PARAMETROFSUB", "tsh", "id",
				"tipo", "clase", "modo", "err");
		Atributo identificador = atributoLexicoPara("IDENTIFICADOR", "lex",
				iden);

		dependencias(tipo.a("tsh"), parametroFSub.a("tsh"));

		dependencias(parametroFSub.a("id"), identificador);
		dependencias(parametroFSub.a("tipo"), tipo.a("tipo"));
		dependencias(parametroFSub.a("err"), tipo.a("err"));

		calculo(tipo.a("tsh"), asignacion);

		calculo(parametroFSub.a("id"), asignacion);
		calculo(parametroFSub.a("clase"), clasePVar);
		calculo(parametroFSub.a("modo"), modoVar);
		calculo(parametroFSub.a("err"), copiaErrores);
		calculo(parametroFSub.a("tipo"), asignacion);

		return parametroFSub;
	}

	public TAtributos CS0(TAtributos variables, TAtributos instrucciones) {
		regla("CuerpoSub -> Variables Instrucciones");

		TAtributos cuerpoSub = atributosPara("CUERPOSUB", "tsh", "etqh",
				"dirh", "ts", "err", "tipo", "cod", "etq");

		dependencias(variables.a("tsh"), cuerpoSub.a("tsh"));
		dependencias(variables.a("dirh"), cuerpoSub.a("dirh"));
		dependencias(instrucciones.a("tsh"), variables.a("ts"));
		dependencias(instrucciones.a("etqh"), cuerpoSub.a("etqh"));

		dependencias(cuerpoSub.a("err"), variables.a("err"),
				instrucciones.a("err"));
		dependencias(cuerpoSub.a("tipo"), variables.a("tipo"),
				instrucciones.a("tipo"));
		dependencias(cuerpoSub.a("ts"), variables.a("ts"));
		dependencias(cuerpoSub.a("etq"), instrucciones.a("etq"));
		dependencias(cuerpoSub.a("cod"), instrucciones.a("cod"),
				variables.a("dir"));

		calculo(variables.a("tsh"), asignacion);
		calculo(variables.a("dirh"), asignacion);
		calculo(instrucciones.a("tsh"), asignacion);
		calculo(instrucciones.a("etqh"), asignacionSuma13);

		calculo(cuerpoSub.a("err"), unirDosErrores);
		calculo(cuerpoSub.a("tipo"), unirDosTipos);
		calculo(cuerpoSub.a("ts"), asignacion);
		calculo(cuerpoSub.a("etq"), asignacionSuma14);
		calculo(cuerpoSub.a("cod"), CodCuerpoSub);
		return cuerpoSub;
	}

	public TAtributos instrucciones0(TAtributos insts) {
		regla("Instrucciones → { Insts} ");

		TAtributos instrucciones = atributosPara("INSTRUCCIONES", "tsh",
				"etqh", "err", "tipo", "cod", "etq");

		dependencias(insts.a("tsh"), instrucciones.a("tsh"));
		dependencias(insts.a("etqh"), instrucciones.a("etqh"));
		dependencias(instrucciones.a("tipo"), insts.a("tipo"));
		dependencias(instrucciones.a("err"), insts.a("err"));
		dependencias(instrucciones.a("cod"), insts.a("cod"), insts.a("err"),
				insts.a("tipo"));
		dependencias(instrucciones.a("etq"), insts.a("etq"));
		calculo(insts.a("tsh"), asignacion);
		calculo(insts.a("etqh"), asignacion);
		calculo(instrucciones.a("tipo"), asignacion);
		calculo(instrucciones.a("err"), copiaErrores);
		calculo(instrucciones.a("cod"), copiaCodigo);
		calculo(instrucciones.a("etq"), asignacion);
		return instrucciones;
	}

	public TAtributos insts0(TAtributos insts1, TAtributos inst) {
		regla("Insts -> Insts ; Inst  ");
		TAtributos insts0 = atributosPara("INSTS", "tsh", "etqh", "etq", "err",
				"tipo", "cod");
		dependencias(insts1.a("tsh"), insts0.a("tsh"));
		dependencias(insts1.a("etqh"), insts0.a("etqh"));
		dependencias(inst.a("tsh"), insts0.a("tsh"));
		dependencias(inst.a("etqh"), insts1.a("etq"));
		dependencias(insts0.a("tipo"), insts1.a("tipo"), inst.a("tipo"));
		dependencias(insts0.a("err"), insts1.a("err"), inst.a("err"));
		dependencias(insts0.a("cod"), insts1.a("cod"), inst.a("cod"),
				insts0.a("err"), insts0.a("tipo"));
		dependencias(insts0.a("etq"), inst.a("etq"));
		calculo(insts1.a("tsh"), asignacion);
		calculo(insts1.a("etqh"), asignacion);
		calculo(inst.a("tsh"), asignacion);
		calculo(inst.a("etqh"), asignacion);
		calculo(insts0.a("tipo"), unirDosTipos);
		calculo(insts0.a("err"), unirDosErrores);
		calculo(insts0.a("cod"), ConcatCodInsts);
		calculo(insts0.a("etq"), asignacion);
		return insts0;
	}

	public TAtributos insts1(TAtributos inst) {
		regla("Insts -> Inst");
		TAtributos insts = atributosPara("INSTS", "tsh", "etqh", "etq", "err",
				"tipo", "cod");
		dependencias(inst.a("etqh"), insts.a("etqh"));
		dependencias(inst.a("tsh"), insts.a("tsh"));
		dependencias(insts.a("err"), inst.a("err"));
		dependencias(insts.a("tipo"), inst.a("tipo"));
		dependencias(insts.a("etq"), inst.a("etq"));
		dependencias(insts.a("cod"), inst.a("cod"), insts.a("err"),
				inst.a("tipo"));
		calculo(inst.a("etqh"), asignacion);
		calculo(inst.a("tsh"), asignacion);
		calculo(insts.a("etq"), asignacion);
		calculo(insts.a("err"), copiaErrores);
		calculo(insts.a("cod"), copiaCodigo);
		calculo(insts.a("tipo"), asignacion);
		return insts;
	}

	public TAtributos inst0(TAtributos desig, TAtributos exp) {
		regla("Inst -> Designador = Exp");
		TAtributos inst = atributosPara("INST", "tsh", "etqh", "irvh", "irfh",
				"tipo", "err", "cod", "etq");
		dependencias(exp.a("tsh"), inst.a("tsh"));
		dependencias(desig.a("tsh"), inst.a("tsh"));
		dependencias(desig.a("etqh"), inst.a("etqh"));
		dependencias(exp.a("etqh"), desig.a("etq"));
		dependencias(inst.a("tipo"), desig.a("tipo"), exp.a("tipo"),
				exp.a("tsh"));
		dependencias(inst.a("etq"), exp.a("etq"), exp.a("esDesig"),
				inst.a("tipo"));
		dependencias(inst.a("err"), inst.a("tsh"), desig.a("id"),
				desig.a("err"), exp.a("err"));
		dependencias(inst.a("cod"), desig.a("cod"), exp.a("cod"),
				exp.a("esDesig"), inst.a("tipo"));
		dependencias(exp.a("irvh"), inst.a("etqh"));
		dependencias(exp.a("irfh"), inst.a("etqh"));
		calculo(exp.a("tsh"), asignacion);
		calculo(desig.a("tsh"), asignacion);
		calculo(desig.a("etqh"), asignacion);
		calculo(exp.a("etqh"), asignacion);
		calculo(inst.a("tipo"), tiposCompatibles);
		calculo(inst.a("etq"), SumaEtqDesignMas1DesigExp);
		calculo(inst.a("err"), ErrDesignInst);
		calculo(inst.a("cod"), CodDesignInst);
		calculo(exp.a("irvh"), asignacion);
		calculo(exp.a("irfh"), asignacion);
		return inst;
	}

	public TAtributos inst1() {
		regla("Inst -> swap1");
		TAtributos inst = atributosPara("INST", "tsh", "etqh", "cod", "etq",
				"tipo", "err");
		dependencias(inst.a("etq"), inst.a("etqh"));
		calculo(inst.a("cod"), creaCodSwap1);
		calculo(inst.a("etq"), asignacionSuma1);
		calculo(inst.a("tipo"), creaTipo);
		calculo(inst.a("err"), creaErrores);
		return inst;
	}

	public TAtributos inst2() {
		regla("Inst -> swap2");
		TAtributos inst = atributosPara("INST", "tsh", "etqh", "cod", "etq",
				"tipo", "err");
		dependencias(inst.a("etq"), inst.a("etqh"));
		calculo(inst.a("cod"), creaCodSwap2);
		calculo(inst.a("etq"), asignacionSuma1);
		calculo(inst.a("tipo"), creaTipo);
		calculo(inst.a("err"), creaErrores);
		return inst;
	}

	public TAtributos inst3(TAtributos desig) {
		regla("Inst -> in (Designador)");
		TAtributos inst = atributosPara("INST", "tsh", "etqh", "cod", "etq",
				"tipo", "err");
		dependencias(desig.a("tsh"), inst.a("tsh"));
		dependencias(desig.a("etqh"), inst.a("etqh"));
		dependencias(inst.a("tipo"), desig.a("tipo"), inst.a("tsh"));
		dependencias(inst.a("err"), desig.a("err"), desig.a("id"),
				inst.a("tsh"), desig.a("tipo"));
		dependencias(inst.a("cod"), desig.a("cod"), desig.a("tipo"),
				inst.a("tsh"));
		dependencias(inst.a("etq"), desig.a("etq"), desig.a("esDesig"));
		calculo(desig.a("tsh"), asignacion);
		calculo(desig.a("etqh"), asignacion);
		calculo(inst.a("tipo"), asignacion);
		calculo(inst.a("err"), copiaErroresInstsIn);
		calculo(inst.a("cod"), codInstIn);
		calculo(inst.a("etq"), etqInstIn);
		return inst;
	}

	public TAtributos inst4(TAtributos exp) {
		regla("Inst -> out(exp) ");
		TAtributos inst = atributosPara("INST", "tsh", "etqh", "err", "tipo",
				"cod", "etq");
		dependencias(exp.a("tsh"), inst.a("tsh"));
		dependencias(exp.a("etqh"), inst.a("etqh"));
		dependencias(inst.a("err"), exp.a("err"));
		dependencias(inst.a("tipo"), exp.a("tipo"));
		dependencias(inst.a("cod"), exp.a("cod"), exp.a("esDesig"),
				exp.a("tipo"), inst.a("tsh"));
		dependencias(inst.a("etq"), exp.a("etq"), exp.a("esDesig"));
		dependencias(exp.a("irvh"), exp.a("etq"), exp.a("esDesig"));
		dependencias(exp.a("irfh"), exp.a("etq"), exp.a("esDesig"));
		calculo(exp.a("tsh"), asignacion);
		calculo(exp.a("etqh"), asignacion);
		calculo(inst.a("err"), copiaErrores);
		calculo(inst.a("tipo"), asignacion);
		calculo(inst.a("cod"), codInstOut);
		calculo(inst.a("etq"), sumaEtqOut);
		calculo(exp.a("irvh"), sumaEtqDesignador);
		calculo(exp.a("irfh"), sumaEtqDesignador);
		return inst;
	}

	public TAtributos inst5(TAtributos exp, TAtributos insts) {
		regla("Inst -> if Exp then Insts endif");
		TAtributos inst = atributosPara("INST", "tsh", "etqh", "err", "tipo",
				"cod", "etq");
		dependencias(exp.a("tsh"), inst.a("tsh"));
		dependencias(exp.a("etqh"), inst.a("etqh"));
		dependencias(insts.a("tsh"), inst.a("tsh"));
		dependencias(insts.a("etqh"), exp.a("etq"), exp.a("esDesig"));
		dependencias(inst.a("err"), exp.a("err"), insts.a("err"));
		dependencias(inst.a("tipo"), exp.a("tipo"), insts.a("tipo"));
		dependencias(inst.a("cod"), exp.a("cod"), insts.a("etq"),
				insts.a("cod"), exp.a("esDesig"));
		dependencias(inst.a("etq"), insts.a("etq"));
		dependencias(exp.a("irvh"), exp.a("etq"), exp.a("esDesig"));
		dependencias(exp.a("irfh"), exp.a("etq"), exp.a("esDesig"));
		calculo(exp.a("tsh"), asignacion);
		calculo(exp.a("etqh"), asignacion);
		calculo(insts.a("tsh"), asignacion);
		calculo(insts.a("etqh"), SumaEtqDesignMas1);
		calculo(inst.a("err"), unirDosErrores);
		calculo(inst.a("tipo"), unirDosTipos);
		calculo(inst.a("cod"), codInstIf);
		calculo(inst.a("etq"), asignacion);
		calculo(exp.a("irvh"), sumaEtqDesignador);
		calculo(exp.a("irfh"), sumaEtqDesignador);
		return inst;
	}

	public TAtributos inst6(TAtributos exp, TAtributos insts0, TAtributos insts1) {
		regla("Inst -> if Exp then Insts1 else Insts2 endif");
		TAtributos inst = atributosPara("INST", "tsh", "etqh", "err", "tipo",
				"cod", "etq");
		dependencias(exp.a("tsh"), inst.a("tsh"));
		dependencias(insts0.a("tsh"), inst.a("tsh"));
		dependencias(insts1.a("tsh"), inst.a("tsh"));
		dependencias(exp.a("etqh"), inst.a("etqh"));
		dependencias(insts0.a("etqh"), exp.a("etq"), exp.a("esDesig"));
		dependencias(insts1.a("etqh"), insts0.a("etq"));
		dependencias(inst.a("err"), exp.a("err"), insts0.a("err"),
				insts1.a("err"));
		dependencias(inst.a("tipo"), exp.a("tipo"), insts0.a("tipo"),
				insts1.a("tipo"));
		dependencias(inst.a("cod"), exp.a("cod"), insts0.a("etq"),
				insts0.a("cod"), insts1.a("etq"), insts1.a("cod"),
				exp.a("esDesig"));
		dependencias(inst.a("etq"), insts1.a("etq"));
		dependencias(exp.a("irvh"), exp.a("etq"), exp.a("esDesig"));
		dependencias(exp.a("irfh"), exp.a("etq"), exp.a("esDesig"));
		calculo(exp.a("tsh"), asignacion);
		calculo(insts0.a("tsh"), asignacion);
		calculo(insts1.a("tsh"), asignacion);
		calculo(exp.a("etqh"), asignacion);
		calculo(insts0.a("etqh"), SumaEtqDesignMas1);
		calculo(insts1.a("etqh"), asignacionSuma1);
		calculo(inst.a("err"), unirTresErrores);
		calculo(inst.a("tipo"), unirTresTipos);
		calculo(inst.a("cod"), codInstIfElse);
		calculo(inst.a("etq"), asignacion);
		calculo(exp.a("irvh"), sumaEtqDesignador);
		calculo(exp.a("irfh"), sumaEtqDesignador);
		return inst;
	}

	public TAtributos inst7(TAtributos exp, TAtributos insts) {
		regla("Inst -> while Exp do Insts endwhile");
		TAtributos inst = atributosPara("INST", "tsh", "etqh", "err", "tipo",
				"cod", "etq");
		dependencias(exp.a("tsh"), inst.a("tsh"));
		dependencias(insts.a("tsh"), inst.a("tsh"));
		dependencias(exp.a("etqh"), inst.a("etqh"));
		dependencias(insts.a("etqh"), exp.a("etq"), exp.a("esDesig"));
		dependencias(inst.a("err"), exp.a("err"), insts.a("err"));
		dependencias(inst.a("tipo"), exp.a("tipo"), insts.a("tipo"));
		dependencias(inst.a("cod"), exp.a("cod"), insts.a("etq"),
				insts.a("cod"), inst.a("etqh"), exp.a("esDesig"));
		dependencias(inst.a("etq"), insts.a("etq"));
		dependencias(exp.a("irvh"), exp.a("etq"), exp.a("esDesig"));
		dependencias(exp.a("irfh"), exp.a("etq"), exp.a("esDesig"));
		calculo(exp.a("tsh"), asignacion);
		calculo(insts.a("tsh"), asignacion);
		calculo(exp.a("etqh"), asignacion);
		calculo(insts.a("etqh"), SumaEtqDesignMas1);
		calculo(inst.a("err"), unirDosErrores);
		calculo(inst.a("tipo"), unirDosTipos);
		calculo(inst.a("cod"), codInstWhile);
		calculo(inst.a("etq"), asignacionSuma1);
		calculo(exp.a("irvh"), sumaEtqDesignador);
		calculo(exp.a("irfh"), sumaEtqDesignador);
		return inst;
	}

	public TAtributos inst8(String iden, TAtributos paramf) {
		regla("Inst = call identificador (ParametrosF) ");
		TAtributos inst = atributosPara("INST", "tsh", "etqh", "err", "etq",
				"cod", "tipo");
		Atributo identificador = atributoLexicoPara("IDENTIFICADOR", "lex",
				iden);
		dependencias(paramf.a("tsh"), inst.a("tsh"));
		dependencias(paramf.a("etqh"), inst.a("etqh"));
		dependencias(paramf.a("paramsh"), inst.a("tsh"), identificador);
		dependencias(inst.a("err"), paramf.a("err"), inst.a("tsh"),
				identificador, paramf.a("numParametros"));
		dependencias(inst.a("etq"), paramf.a("etq"));
		dependencias(inst.a("cod"), inst.a("etq"), paramf.a("cod"),
				identificador, inst.a("tsh"));
		dependencias(inst.a("tipo"), paramf.a("tipo"));
		calculo(paramf.a("tsh"), asignacion);
		calculo(paramf.a("etqh"), asignacionSuma5);
		calculo(paramf.a("paramsh"), paramsHeredado);
		calculo(inst.a("err"), copiaErroresCall);
		calculo(inst.a("etq"), asignacionSuma1);
		calculo(inst.a("cod"), codCall);
		calculo(inst.a("tipo"), asignacion);
		return inst;
	}

	public TAtributos paramsFCall0(TAtributos paramfuncall) {
		regla("ParametrosF -> ParametrosFun");
		TAtributos parametrosfcall = atributosPara("PARAMETROSFCALL",
				"paramsh", "tsh", "etqh", "etq", "cod", "err", "tipo",
				"numParametros");
		dependencias(paramfuncall.a("paramsh"), parametrosfcall.a("paramsh"));
		dependencias(paramfuncall.a("tsh"), parametrosfcall.a("tsh"));
		dependencias(paramfuncall.a("etqh"), parametrosfcall.a("etqh"));
		dependencias(parametrosfcall.a("etq"), paramfuncall.a("etq"));
		dependencias(parametrosfcall.a("cod"), paramfuncall.a("cod"));
		dependencias(parametrosfcall.a("tipo"), paramfuncall.a("tipo"));
		dependencias(parametrosfcall.a("err"), paramfuncall.a("err"));
		dependencias(parametrosfcall.a("numParametros"),
				paramfuncall.a("numParametros"));
		calculo(paramfuncall.a("paramsh"), asignacion);
		calculo(paramfuncall.a("tsh"), asignacion);
		calculo(paramfuncall.a("etqh"), asignacionSuma3);
		calculo(parametrosfcall.a("err"), copiaErrores);
		calculo(parametrosfcall.a("etq"), asignacionSuma1);
		calculo(parametrosfcall.a("cod"), CodigoParamsFCall0);
		calculo(parametrosfcall.a("tipo"), asignacion);
		calculo(parametrosfcall.a("numParametros"), asignacion);
		return parametrosfcall;
	}

	public TAtributos paramsFCall1() {
		regla("ParametrosF -> lambda");
		TAtributos parametrosfcall = atributosPara("PARAMETROSFCALL",
				"paramsh", "etqh", "tsh", "tipo", "etq", "err", "cod",
				"numParametros");
		dependencias(parametrosfcall.a("etq"), parametrosfcall.a("etqh"));
		calculo(parametrosfcall.a("etq"), asignacion);
		calculo(parametrosfcall.a("tipo"), creaTipo);
		calculo(parametrosfcall.a("err"), creaErrores);
		calculo(parametrosfcall.a("cod"), codVacio);
		calculo(parametrosfcall.a("tipo"), creaTipo);
		calculo(parametrosfcall.a("numParametros"), asignacion0);
		return parametrosfcall;
	}

	public TAtributos paramsFunCall0(TAtributos paramsfuncall1,
			TAtributos paramfuncall) {
		regla("ParametrosFunC-> ParametrosFunC , ParametroFunC");

		TAtributos paramfuncall0 = atributosPara("PARAMETROSFUNCALL",
				"paramsh", "tsh", "etqh", "etq", "err", "cod", "tipo",
				"numParametros");

		dependencias(paramsfuncall1.a("paramsh"), paramfuncall0.a("paramsh"));
		dependencias(paramfuncall.a("paramsh"), paramfuncall0.a("paramsh"));
		dependencias(paramsfuncall1.a("tsh"), paramfuncall0.a("tsh"));
		dependencias(paramfuncall.a("tsh"), paramfuncall0.a("tsh"));
		dependencias(paramsfuncall1.a("etqh"), paramfuncall0.a("etqh"));
		dependencias(paramfuncall.a("etqh"), paramsfuncall1.a("etq"));
		dependencias(paramfuncall0.a("etq"), paramfuncall.a("etq"));
		dependencias(paramfuncall0.a("cod"), paramsfuncall1.a("cod"),
				paramfuncall.a("cod"));
		dependencias(paramfuncall0.a("err"), paramsfuncall1.a("err"),
				paramfuncall.a("err"));
		dependencias(paramfuncall0.a("tipo"), paramsfuncall1.a("tipo"),
				paramfuncall.a("tipo"));
		dependencias(paramfuncall0.a("numParametros"),
				paramsfuncall1.a("numParametros"));
		calculo(paramsfuncall1.a("paramsh"), asignacion);
		calculo(paramfuncall.a("paramsh"), asignacion);
		calculo(paramsfuncall1.a("tsh"), asignacion);
		calculo(paramfuncall.a("tsh"), asignacion);
		calculo(paramsfuncall1.a("etqh"), asignacion);
		calculo(paramfuncall.a("etqh"), asignacion);
		calculo(paramfuncall0.a("etq"), asignacion);
		calculo(paramfuncall0.a("err"), unirDosErrores);
		calculo(paramfuncall0.a("cod"), concatenaDosCod);
		calculo(paramfuncall0.a("tipo"), unirDosTipos);
		calculo(paramfuncall0.a("numParametros"), asignacionSuma1);
		return paramfuncall0;
	}

	public TAtributos paramsFunCall1(TAtributos paramfunc) {
		regla("ParametrosFunC-> ParametroFunC");
		TAtributos paramsfuncall = atributosPara("PARAMETROSFUNCALL",
				"paramsh", "tsh", "err", "etqh", "cod", "etq", "tipo",
				"numParametros");

		dependencias(paramfunc.a("paramsh"), paramsfuncall.a("paramsh"));
		dependencias(paramfunc.a("tsh"), paramsfuncall.a("tsh"));
		dependencias(paramfunc.a("etqh"), paramsfuncall.a("etqh"));
		dependencias(paramsfuncall.a("cod"), paramfunc.a("cod"),
				paramfunc.a("err"), paramfunc.a("tipo"));
		dependencias(paramsfuncall.a("etq"), paramfunc.a("etq"));
		dependencias(paramsfuncall.a("err"), paramfunc.a("err"));
		dependencias(paramsfuncall.a("tipo"), paramfunc.a("tipo"));
		calculo(paramfunc.a("paramsh"), asignacion);
		calculo(paramfunc.a("tsh"), asignacion);
		calculo(paramfunc.a("etqh"), asignacion);
		calculo(paramsfuncall.a("cod"), copiaCodigo);
		calculo(paramsfuncall.a("etq"), asignacion);
		calculo(paramsfuncall.a("tipo"), asignacion);
		calculo(paramsfuncall.a("err"), copiaErrores);
		calculo(paramsfuncall.a("numParametros"), asignacion1);
		return paramsfuncall;
	}

	public TAtributos paramFunCall0(String iden, TAtributos exp) {
		regla("ParametroFunC -> identificador = Exp");
		TAtributos paramfuncall = atributosPara("PARAMETROFUNCALL", "tsh",
				"etqh", "err", "cod", "etq", "tipo", "paramsh");
		Atributo identificador = atributoLexicoPara("IDENTIFICADOR", "lex",
				iden);

		dependencias(exp.a("tsh"), paramfuncall.a("tsh"));
		dependencias(exp.a("etqh"), paramfuncall.a("etqh"));
		dependencias(paramfuncall.a("err"), exp.a("err"),
				paramfuncall.a("tsh"), identificador, paramfuncall.a("paramsh"));
		dependencias(paramfuncall.a("cod"), exp.a("cod"), exp.a("esDesig"),
				paramfuncall.a("paramsh"), identificador);
		dependencias(paramfuncall.a("etq"), exp.a("etq"), exp.a("esDesig"),
				paramfuncall.a("paramsh"));
		dependencias(paramfuncall.a("tipo"), exp.a("tipo"),
				paramfuncall.a("paramsh"), identificador, paramfuncall.a("tsh"));
		calculo(exp.a("tsh"), asignacion);
		calculo(exp.a("etqh"), asignacionSuma1);
		calculo(paramfuncall.a("err"), errCall);
		calculo(paramfuncall.a("cod"), codCallId);
		calculo(paramfuncall.a("etq"), etqCall);
		calculo(paramfuncall.a("tipo"), tipoCompatibleCall);
		return paramfuncall;
	}

	public TAtributos exp0(TAtributos expnivel10, TAtributos ops0,
			TAtributos expnivel11) {
		regla("Exp -> ExpNivel10 ops0 ExpNivel11");
		TAtributos exp = atributosPara("EXP", "tsh", "etqh", "tipo", "err",
				"cod", "etq", "esDesig", "irvh", "irfh");
		dependencias(expnivel10.a("tsh"), exp.a("tsh"));
		dependencias(expnivel11.a("tsh"), exp.a("tsh"));
		dependencias(expnivel10.a("etqh"), exp.a("etqh"));
		dependencias(expnivel11.a("etqh"), expnivel10.a("etq"));
		dependencias(exp.a("tipo"), ops0.a("op"), expnivel10.a("tipo"),
				expnivel11.a("tipo"));
		dependencias(exp.a("err"), expnivel10.a("err"), expnivel11.a("err"));
		dependencias(exp.a("cod"), expnivel10.a("cod"), expnivel11.a("cod"),
				ops0.a("op"), expnivel10.a("esDesig"), expnivel11.a("esDesig"));
		dependencias(exp.a("etq"), expnivel11.a("etq"),
				expnivel10.a("esDesig"), expnivel11.a("esDesig"));
		dependencias(expnivel10.a("irvh"), expnivel10.a("etq"),
				expnivel10.a("esDesig"));
		dependencias(expnivel10.a("irfh"), expnivel10.a("etq"),
				expnivel10.a("esDesig"));
		dependencias(expnivel11.a("irvh"), expnivel11.a("etq"),
				expnivel11.a("esDesig"));
		dependencias(expnivel11.a("irfh"), expnivel11.a("etq"),
				expnivel11.a("esDesig"));
		calculo(expnivel10.a("tsh"), asignacion);
		calculo(expnivel11.a("tsh"), asignacion);
		calculo(expnivel10.a("etqh"), asignacion);
		calculo(expnivel11.a("etqh"), asignacion);
		calculo(exp.a("tipo"), TipoResult2);
		calculo(exp.a("err"), unirDosErrores);
		calculo(exp.a("cod"), codExp);
		calculo(exp.a("etq"), sumaEtqExp);
		calculo(exp.a("esDesig"), AsignFalseBool);
		calculo(expnivel10.a("irvh"), sumaEtqDesignador);
		calculo(expnivel10.a("irfh"), sumaEtqDesignador);
		calculo(expnivel11.a("irvh"), sumaEtqDesignador);
		calculo(expnivel11.a("irfh"), sumaEtqDesignador);
		return exp;
	}

	public TAtributos exp1(TAtributos expnivel1) {
		regla("Exp -> ExpNivel1");
		TAtributos exp = atributosPara("EXP", "tsh", "etqh", "tipo", "err",
				"cod", "etq", "esDesig", "irvh", "irfh");

		dependencias(expnivel1.a("irfh"), exp.a("irfh"));
		dependencias(expnivel1.a("irvh"), exp.a("irvh"));
		dependencias(expnivel1.a("etqh"), exp.a("etqh"));
		dependencias(expnivel1.a("tsh"), exp.a("tsh"));
		dependencias(exp.a("tipo"), expnivel1.a("tipo"));
		dependencias(exp.a("err"), expnivel1.a("err"));
		dependencias(exp.a("cod"), expnivel1.a("cod"), exp.a("err"),
				exp.a("tipo"));
		dependencias(exp.a("etq"), expnivel1.a("etq"));
		dependencias(exp.a("esDesig"), expnivel1.a("esDesig"));
		calculo(expnivel1.a("tsh"), asignacion);
		calculo(expnivel1.a("etqh"), asignacion);
		calculo(exp.a("tipo"), asignacion);
		calculo(exp.a("err"), copiaErrores);
		calculo(exp.a("cod"), copiaCodigo);
		calculo(exp.a("etq"), asignacion);
		calculo(exp.a("esDesig"), asignacion);
		calculo(expnivel1.a("irvh"), asignacion);
		calculo(expnivel1.a("irfh"), asignacion);
		return exp;
	}

	public TAtributos ops0Menor() {
		regla("Ops0 -> <");
		TAtributos ops0 = atributosPara("OPS0", "op");
		calculo(ops0.a("op"), creaCodMen);
		return ops0;
	}

	public TAtributos ops0Mayor() {
		regla("Ops0 -> >");
		TAtributos ops0 = atributosPara("OPS0", "op");
		calculo(ops0.a("op"), creaCodMay);
		return ops0;
	}

	public TAtributos ops0MenorIgual() {
		regla("Ops0 -> <=");
		TAtributos ops0 = atributosPara("OPS0", "op");
		calculo(ops0.a("op"), creaCodMenIgual);
		return ops0;
	}

	public TAtributos ops0MayorIgual() {
		regla("Ops0 -> >=");
		TAtributos ops0 = atributosPara("OPS0", "op");
		calculo(ops0.a("op"), creaCodMayIgual);
		return ops0;
	}

	public TAtributos ops0Igual() {
		regla("Ops0 -> ==");
		TAtributos ops0 = atributosPara("OPS0", "op");
		calculo(ops0.a("op"), creaCodIgual);
		return ops0;
	}

	public TAtributos ops0Distinto() {
		regla("Ops0 -> !=");
		TAtributos ops0 = atributosPara("OPS0", "op");
		calculo(ops0.a("op"), creaCodNoIgual);
		return ops0;
	}

	public TAtributos exp10(TAtributos exp11, TAtributos ops1, TAtributos exp2) {
		regla("ExpNivel1 -> ExpNivel1 ops1 ExpNivel2");
		TAtributos exp10 = atributosPara("EXPNIVEL1", "etqh", "tsh", "tipo",
				"err", "cod", "etq", "esDesig", "irvh", "irfh");
		dependencias(exp11.a("tsh"), exp10.a("tsh"));
		dependencias(exp2.a("tsh"), exp10.a("tsh"));
		dependencias(exp11.a("etqh"), exp10.a("etqh"));
		dependencias(exp2.a("etqh"), exp11.a("etq"), ops1.a("op"));
		dependencias(exp10.a("tipo"), ops1.a("op"), exp11.a("tipo"),
				exp2.a("tipo"));
		dependencias(exp10.a("err"), exp11.a("err"), exp2.a("err"));
		dependencias(exp10.a("cod"), exp11.a("cod"), exp10.a("irvh"),
				exp2.a("cod"), exp11.a("esDesig"), exp2.a("esDesig"),
				ops1.a("op"), exp10.a("tipo"));
		dependencias(exp10.a("etq"), exp2.a("etq"), exp11.a("esDesig"),
				exp2.a("esDesig"), ops1.a("op"));
		dependencias(exp11.a("irvh"), ops1.a("op"), exp10.a("irvh"),
				exp11.a("etq"), exp11.a("esDesig"));
		dependencias(exp11.a("irfh"), ops1.a("op"), exp11.a("etq"),
				exp11.a("esDesig"));
		dependencias(exp2.a("irvh"), ops1.a("op"), exp10.a("irvh"),
				exp2.a("etq"), exp2.a("esDesig"));
		dependencias(exp2.a("irfh"), ops1.a("op"), exp11.a("irfh"),
				exp2.a("etq"), exp2.a("esDesig"));
		calculo(exp11.a("tsh"), asignacion);
		calculo(exp2.a("tsh"), asignacion);
		calculo(exp11.a("etqh"), asignacion);
		calculo(exp2.a("etqh"), etqhSuma3);
		calculo(exp10.a("tipo"), TipoResult2);
		calculo(exp10.a("err"), unirDosErrores);
		calculo(exp10.a("cod"), codExpnivel1);
		calculo(exp10.a("etq"), etqExpnivel1);
		calculo(exp10.a("esDesig"), AsignFalseBool);
		calculo(exp11.a("irvh"), irf_irv_Op);
		calculo(exp11.a("irfh"), irf_irv_OpSuma2);
		calculo(exp2.a("irvh"), irf_irv_Op);
		calculo(exp2.a("irfh"), irf_irv_Op);
		return exp10;
	}

	public TAtributos exp11(TAtributos exp2) {
		regla("ExpNivel1 -> ExpNivel2");
		TAtributos exp1 = atributosPara("EXPNIVEL1", "irfh", "irvh", "tipo",
				"err", "cod", "etq", "tsh", "etqh", "esDesig");
		dependencias(exp2.a("tsh"), exp1.a("tsh"));
		dependencias(exp2.a("etqh"), exp1.a("etqh"));
		dependencias(exp2.a("irvh"), exp1.a("irvh"));
		dependencias(exp2.a("irfh"), exp1.a("irfh"));
		dependencias(exp1.a("tipo"), exp2.a("tipo"));
		dependencias(exp1.a("err"), exp2.a("err"));
		dependencias(exp1.a("cod"), exp2.a("cod"), exp1.a("err"),
				exp1.a("tipo"));
		dependencias(exp1.a("etq"), exp2.a("etq"));
		dependencias(exp1.a("esDesig"), exp2.a("esDesig"));
		calculo(exp2.a("tsh"), asignacion);
		calculo(exp2.a("etqh"), asignacion);
		calculo(exp1.a("tipo"), asignacion);
		calculo(exp1.a("err"), copiaErrores);
		calculo(exp1.a("cod"), copiaCodigo);
		calculo(exp1.a("etq"), asignacion);
		calculo(exp1.a("esDesig"), asignacion);
		calculo(exp2.a("irvh"), asignacion);
		calculo(exp2.a("irfh"), asignacion);
		return exp1;
	}

	public TAtributos ops1Suma() {
		regla("Ops1 -> +");
		TAtributos ops1 = atributosPara("OPS1", "op");
		calculo(ops1.a("op"), creaCodMas);
		return ops1;
	}

	public TAtributos ops1Resta() {
		regla("Ops1 -> -");
		TAtributos ops1 = atributosPara("OPS1", "op");
		calculo(ops1.a("op"), creaCodMenos);
		return ops1;
	}

	public TAtributos ops1Or() {
		regla("ops1 -> or");
		TAtributos ops1 = atributosPara("OPS1", "op");
		calculo(ops1.a("op"), creaCodOr);

		return ops1;
	}

	public TAtributos exp20(TAtributos exp21, TAtributos ops2, TAtributos exp3) {
		regla("ExpNivel2 -> ExpNivel2 ops2 ExpNivel3");
		TAtributos exp20 = atributosPara("EXPNIVEL2", "tsh", "etqh", "irvh",
				"irfh", "tipo", "err", "cod", "etq", "esDesig");
		dependencias(exp21.a("tsh"), exp20.a("tsh"));
		dependencias(exp3.a("tsh"), exp20.a("tsh"));
		dependencias(exp21.a("etqh"), exp20.a("etqh"));
		dependencias(exp3.a("etqh"), exp21.a("etq"), ops2.a("op"));
		dependencias(exp20.a("tipo"), ops2.a("op"), exp21.a("tipo"),
				exp3.a("tipo"));
		dependencias(exp20.a("err"), exp21.a("err"), exp3.a("err"));
		dependencias(exp20.a("cod"), ops2.a("op"), exp21.a("cod"),
				exp20.a("irfh"), exp3.a("cod"), exp21.a("esDesig"),
				exp3.a("esDesig"), exp20.a("tipo"));
		dependencias(exp20.a("etq"), ops2.a("op"), exp3.a("etq"),
				exp21.a("esDesig"), exp3.a("esDesig"));
		dependencias(exp21.a("irvh"), ops2.a("op"), exp21.a("etq"),
				exp21.a("esDesig"));
		dependencias(exp21.a("irfh"), ops2.a("op"), exp20.a("irfh"),
				exp21.a("etq"), exp21.a("esDesig"));
		dependencias(exp3.a("irvh"), ops2.a("op"), exp20.a("irvh"),
				exp3.a("etq"), exp3.a("esDesig"));
		dependencias(exp3.a("irfh"), ops2.a("op"), exp20.a("irfh"),
				exp3.a("etq"), exp3.a("esDesig"));
		calculo(exp21.a("tsh"), asignacion);
		calculo(exp3.a("tsh"), asignacion);
		calculo(exp21.a("etqh"), asignacion);
		calculo(exp3.a("etqh"), etqhSuma3Expnivel2);
		calculo(exp20.a("esDesig"), AsignFalseBool);
		calculo(exp20.a("tipo"), TipoResult2);
		calculo(exp20.a("err"), unirDosErrores);
		calculo(exp20.a("cod"), codExpnivel2);
		calculo(exp20.a("etq"), etqExpnivel2);
		calculo(exp21.a("irvh"), irf_irv_OpAndSuma2);
		calculo(exp21.a("irfh"), irf_irv_OpAnd);
		calculo(exp3.a("irvh"), irf_irv_OpAnd);
		calculo(exp3.a("irfh"), irf_irv_OpAnd);
		return exp20;
	}

	public TAtributos exp21(TAtributos exp3) {
		regla("ExpNivel2 -> ExpNivel3");
		TAtributos exp2 = atributosPara("EXPNIVEL2", "tsh", "etqh", "irvh",
				"irfh", "tipo", "err", "cod", "etq", "esDesig");
		dependencias(exp3.a("tsh"), exp2.a("tsh"));
		dependencias(exp3.a("etqh"), exp2.a("etqh"));
		dependencias(exp2.a("tipo"), exp3.a("tipo"));
		dependencias(exp2.a("err"), exp3.a("err"));
		dependencias(exp2.a("cod"), exp3.a("cod"), exp2.a("err"),
				exp2.a("tipo"));
		dependencias(exp2.a("etq"), exp3.a("etq"));
		dependencias(exp2.a("esDesig"), exp3.a("esDesig"));
		dependencias(exp3.a("irvh"), exp2.a("irvh"));
		dependencias(exp3.a("irfh"), exp2.a("irfh"));
		calculo(exp3.a("tsh"), asignacion);
		calculo(exp3.a("etqh"), asignacion);
		calculo(exp2.a("tipo"), asignacion);
		calculo(exp2.a("err"), copiaErrores);
		calculo(exp2.a("cod"), copiaCodigo);
		calculo(exp2.a("etq"), asignacion);
		calculo(exp2.a("esDesig"), asignacion);
		calculo(exp3.a("irvh"), asignacion);
		calculo(exp3.a("irfh"), asignacion);
		return exp2;
	}

	public TAtributos ops2Mul() {
		regla("Ops2 -> *");
		TAtributos ops2 = atributosPara("OPS2", "op");
		calculo(ops2.a("op"), creaCodMul);
		return ops2;
	}

	public TAtributos ops2Div() {
		regla("Ops2 -> /");
		TAtributos ops2 = atributosPara("OPS2", "op");
		calculo(ops2.a("op"), creaCodDiv);
		return ops2;
	}

	public TAtributos ops2Mod() {
		regla("Ops2 -> %");
		TAtributos ops2 = atributosPara("OPS2", "op");
		calculo(ops2.a("op"), creaCodMod);
		return ops2;
	}

	public TAtributos ops2And() {
		regla("Ops2 -> and");
		TAtributos ops2 = atributosPara("OPS2", "op");
		calculo(ops2.a("op"), creaCodAnd);
		return ops2;
	}

	public TAtributos exp30(TAtributos exp4, TAtributos ops3, TAtributos exp31) {
		regla("ExpNivel3 -> ExpNivel4 ops3 ExpNivel3");
		TAtributos exp30 = atributosPara("EXPNIVEL3", "etqh", "tsh", "tipo",
				"err", "cod", "etq", "esDesig", "irvh", "irfh");
		dependencias(exp4.a("tsh"), exp30.a("tsh"));
		dependencias(exp31.a("tsh"), exp30.a("tsh"));
		dependencias(exp4.a("etqh"), exp30.a("etqh"));
		dependencias(exp31.a("etqh"), exp4.a("etq"));
		dependencias(exp30.a("tipo"), ops3.a("op"), exp31.a("tipo"),
				exp4.a("tipo"));
		dependencias(exp30.a("err"), exp31.a("err"), exp4.a("err"));
		dependencias(exp30.a("cod"), exp4.a("cod"), exp31.a("cod"),
				ops3.a("op"), exp4.a("esDesig"), exp31.a("esDesig"));
		dependencias(exp30.a("etq"), exp31.a("etq"), exp4.a("esDesig"),
				exp31.a("esDesig"));
		dependencias(exp4.a("irvh"), exp4.a("etq"), exp4.a("esDesig"));
		dependencias(exp4.a("irfh"), exp4.a("etq"), exp4.a("esDesig"));
		dependencias(exp31.a("irvh"), exp31.a("etq"), exp31.a("esDesig"));
		dependencias(exp31.a("irfh"), exp31.a("etq"), exp31.a("esDesig"));
		calculo(exp4.a("tsh"), asignacion);
		calculo(exp31.a("tsh"), asignacion);
		calculo(exp4.a("etqh"), asignacion);
		calculo(exp31.a("etqh"), asignacion);
		calculo(exp30.a("tipo"), TipoResult2);
		calculo(exp30.a("err"), unirDosErrores);
		calculo(exp30.a("cod"), codExp);
		calculo(exp30.a("etq"), sumaEtqExp);
		calculo(exp30.a("esDesig"), AsignFalseBool);
		calculo(exp4.a("irvh"), sumaEtqDesignador);
		calculo(exp4.a("irfh"), sumaEtqDesignador);
		calculo(exp31.a("irvh"), sumaEtqDesignador);
		calculo(exp31.a("irfh"), sumaEtqDesignador);
		return exp30;
	}

	public TAtributos exp31(TAtributos exp4) {
		regla("ExpNivel3 -> ExpNivel4");
		TAtributos exp3 = atributosPara("EXPNIVEL3", "tsh", "etqh", "irvh",
				"irfh", "tipo", "err", "cod", "etq", "esDesig");

		dependencias(exp4.a("tsh"), exp3.a("tsh"));
		dependencias(exp4.a("etqh"), exp3.a("etqh"));
		dependencias(exp3.a("tipo"), exp4.a("tipo"));
		dependencias(exp3.a("err"), exp4.a("err"));
		dependencias(exp3.a("cod"), exp4.a("cod"), exp3.a("err"),
				exp3.a("tipo"));
		dependencias(exp3.a("etq"), exp4.a("etq"));
		dependencias(exp3.a("esDesig"), exp4.a("esDesig"));
		dependencias(exp4.a("irvh"), exp3.a("irvh"));
		dependencias(exp4.a("irfh"), exp3.a("irfh"));

		calculo(exp4.a("tsh"), asignacion);
		calculo(exp4.a("etqh"), asignacion);
		calculo(exp3.a("tipo"), asignacion);
		calculo(exp3.a("err"), copiaErrores);
		calculo(exp3.a("cod"), copiaCodigo);
		calculo(exp3.a("etq"), asignacion);
		calculo(exp3.a("esDesig"), asignacion);
		calculo(exp4.a("irvh"), asignacion);
		calculo(exp4.a("irfh"), asignacion);
		return exp3;
	}

	public TAtributos ops3DespDer() {
		regla("Ops3 -> >>");
		TAtributos ops3 = atributosPara("OPS3", "op");
		calculo(ops3.a("op"), CreaCodDespDerecha);
		return ops3;
	}

	public TAtributos ops3DespIzq() {
		regla("Ops3 -> <<");
		TAtributos ops3 = atributosPara("OPS3", "op");
		calculo(ops3.a("op"), creaCodDespIzq);
		return ops3;
	}

	public TAtributos exp40(TAtributos ops4, TAtributos exp5) {
		regla("ExpNivel4 -> Ops4 expnivel5");
		TAtributos exp4 = atributosPara("EXPNIVEL4", "etqh", "tsh", "irvh",
				"irfh", "tipo", "err", "cod", "etq", "esDesig");
		dependencias(exp5.a("tsh"), exp4.a("tsh"));
		dependencias(exp5.a("etqh"), exp4.a("etqh"));
		dependencias(exp4.a("tipo"), ops4.a("op"), exp5.a("tipo"));
		dependencias(exp4.a("err"), exp5.a("err"));
		dependencias(exp4.a("cod"), exp5.a("cod"), ops4.a("op"),
				exp5.a("esDesig"), exp4.a("tipo"));
		dependencias(exp4.a("etq"), exp5.a("etq"), exp5.a("esDesig"));
		dependencias(exp5.a("irvh"), exp4.a("irvh"));
		dependencias(exp5.a("irfh"), exp4.a("irfh"));
		calculo(exp5.a("tsh"), asignacion);
		calculo(exp5.a("etqh"), asignacion);
		calculo(exp4.a("tipo"), TipoResult1);
		calculo(exp4.a("err"), copiaErrores);
		calculo(exp4.a("cod"), codExpnivel4);
		calculo(exp4.a("etq"), SumaEtqDesignMas1);
		calculo(exp4.a("esDesig"), AsignFalseBool);
		calculo(exp5.a("irvh"), asignacion);
		calculo(exp5.a("irfh"), asignacion);
		return exp4;
	}

	public TAtributos exp41(TAtributos exp) {
		regla("ExpNivel4 -> ( Exp ) ");
		TAtributos exp4 = atributosPara("EXPNIVEL4", "irvh", "irfh", "tsh",
				"etqh", "tipo", "err", "cod", "etq", "esDesig");

		dependencias(exp.a("tsh"), exp4.a("tsh"));
		dependencias(exp.a("etqh"), exp4.a("etqh"));
		dependencias(exp4.a("tipo"), exp.a("tipo"));
		dependencias(exp4.a("err"), exp.a("err"));
		dependencias(exp4.a("cod"), exp.a("cod"), exp4.a("err"), exp4.a("tipo"));
		dependencias(exp4.a("etq"), exp.a("etq"));
		dependencias(exp4.a("esDesig"), exp.a("esDesig"));
		dependencias(exp.a("irvh"), exp4.a("irvh"));
		dependencias(exp.a("irfh"), exp4.a("irfh"));
		calculo(exp.a("tsh"), asignacion);
		calculo(exp.a("etqh"), asignacion);
		calculo(exp4.a("tipo"), asignacion);
		calculo(exp4.a("err"), copiaErrores);
		calculo(exp4.a("cod"), copiaCodigo);
		calculo(exp4.a("etq"), asignacion);
		calculo(exp4.a("esDesig"), asignacion);
		calculo(exp.a("irvh"), asignacion);
		calculo(exp.a("irfh"), asignacion);
		return exp4;
	}

	public TAtributos exp43(TAtributos exp5) {
		regla("ExpNivel4 -> ExpNivel5 ");
		TAtributos exp4 = atributosPara("EXPNIVEL4", "irvh", "irfh", "tsh",
				"etqh", "tipo", "err", "cod", "etq", "esDesig");
		dependencias(exp5.a("tsh"), exp4.a("tsh"));
		dependencias(exp5.a("etqh"), exp4.a("etqh"));
		dependencias(exp4.a("tipo"), exp5.a("tipo"));
		dependencias(exp4.a("err"), exp5.a("err"));
		dependencias(exp4.a("cod"), exp5.a("cod"), exp4.a("err"),
				exp4.a("tipo"));
		dependencias(exp4.a("etq"), exp5.a("etq"));
		dependencias(exp4.a("esDesig"), exp5.a("esDesig"));
		dependencias(exp5.a("irvh"), exp4.a("irvh"));
		dependencias(exp5.a("irfh"), exp4.a("irfh"));
		calculo(exp5.a("tsh"), asignacion);
		calculo(exp5.a("etqh"), asignacion);
		calculo(exp4.a("err"), copiaErrores);
		calculo(exp4.a("tipo"), asignacion);
		calculo(exp4.a("cod"), copiaCodigo);
		calculo(exp4.a("etq"), asignacion);
		calculo(exp4.a("esDesig"), asignacion);
		calculo(exp5.a("irfh"), asignacion);
		calculo(exp5.a("irvh"), asignacion);
		return exp4;
	}

	public TAtributos exp5Natural(String vnatural) {
		regla("expnivel5 -> VNATURAL");
		TAtributos expnivel5 = atributosPara("EXPNIVEL5", "irvh", "irfh",
				"etqh", "err", "tsh", "tipo", "cod", "etq", "esDesig");
		Atributo astring = atributoLexicoPara("STRING", "lex", vnatural);
		dependencias(expnivel5.a("etq"), expnivel5.a("etqh"));
		dependencias(expnivel5.a("cod"), astring);
		calculo(expnivel5.a("err"), creaErrores);
		calculo(expnivel5.a("tipo"), creaNatural);
		calculo(expnivel5.a("cod"), codApilaValor);
		calculo(expnivel5.a("etq"), asignacionSuma1);
		calculo(expnivel5.a("esDesig"), AsignFalseBool);
		return expnivel5;
	}

	public TAtributos exp5Integer(String vinteger) {
		regla("expnivel5 -> VINTEGER");
		TAtributos expnivel5 = atributosPara("EXPNIVEL5", "err", "irvh",
				"irfh", "etqh", "tsh", "tipo", "cod", "etq", "esDesig");

		Atributo astring = atributoLexicoPara("STRING", "lex", vinteger);
		dependencias(expnivel5.a("etq"), expnivel5.a("etqh"));
		dependencias(expnivel5.a("cod"), astring);
		calculo(expnivel5.a("err"), creaErrores);
		calculo(expnivel5.a("tipo"), creaInt);
		calculo(expnivel5.a("cod"), codApilaValor);
		calculo(expnivel5.a("etq"), asignacionSuma1);
		calculo(expnivel5.a("esDesig"), AsignFalseBool);
		return expnivel5;
	}

	public TAtributos exp5Character(String vchar) {
		regla("expnivel5 -> VCHAR");
		TAtributos expnivel5 = atributosPara("EXPNIVEL5", "err", "irvh",
				"irfh", "etqh", "tsh", "tipo", "cod", "etq", "esDesig");
		Atributo astring = atributoLexicoPara("STRING", "lex", vchar);
		dependencias(expnivel5.a("etq"), expnivel5.a("etqh"));
		dependencias(expnivel5.a("cod"), astring);
		calculo(expnivel5.a("err"), creaErrores);
		calculo(expnivel5.a("tipo"), creaChar);
		calculo(expnivel5.a("cod"), CodApilaChar);
		calculo(expnivel5.a("etq"), asignacionSuma1);
		calculo(expnivel5.a("esDesig"), AsignFalseBool);
		return expnivel5;
	}

	public TAtributos exp5Float(String vfloat) {
		regla("expnivel5 -> VFLOAT");
		TAtributos expnivel5 = atributosPara("EXPNIVEL5", "err", "etqh", "tsh",
				"irvh", "irfh", "tipo", "cod", "etq", "esDesig");

		Atributo astring = atributoLexicoPara("STRING", "lex", vfloat);
		dependencias(expnivel5.a("etq"), expnivel5.a("etqh"));
		dependencias(expnivel5.a("cod"), astring);
		calculo(expnivel5.a("err"), creaErrores);
		calculo(expnivel5.a("tipo"), creaFloat);
		calculo(expnivel5.a("cod"), codApilaValor);
		calculo(expnivel5.a("etq"), asignacionSuma1);
		calculo(expnivel5.a("esDesig"), AsignFalseBool);
		return expnivel5;
	}

	public TAtributos exp5FloatNeg(String vfloat) {
		regla("expnivel5 -> float");
		TAtributos valorInst = atributosPara("VALORINST");
		return valorInst;
	}

	public TAtributos exp5True() {
		regla("expnivel5 -> TRUE");
		TAtributos expnivel5 = atributosPara("EXPNIVEL5", "err", "irvh",
				"irfh", "etqh", "tsh", "tipo", "cod", "etq", "esDesig");
		dependencias(expnivel5.a("etq"), expnivel5.a("etqh"));
		calculo(expnivel5.a("err"), creaErrores);
		calculo(expnivel5.a("tipo"), creaBool);
		calculo(expnivel5.a("cod"), codApilatrue);
		calculo(expnivel5.a("etq"), asignacionSuma1);
		calculo(expnivel5.a("esDesig"), AsignFalseBool);
		return expnivel5;
	}

	public TAtributos exp5False() {
		regla("expnivel5 -> FALSE");
		TAtributos expnivel5 = atributosPara("EXPNIVEL5", "err", "irvh",
				"irfh", "etqh", "tsh", "tipo", "cod", "etq", "esDesig");
		dependencias(expnivel5.a("etq"), expnivel5.a("etqh"));
		calculo(expnivel5.a("err"), creaErrores);
		calculo(expnivel5.a("tipo"), creaBool);
		calculo(expnivel5.a("cod"), codApilafalse);
		calculo(expnivel5.a("etq"), asignacionSuma1);
		calculo(expnivel5.a("esDesig"), AsignFalseBool);
		return expnivel5;
	}

	public TAtributos exp5Desig(TAtributos desig) {
		regla("expnivel5 -> Designador");
		TAtributos expnivel5 = atributosPara("EXPNIVEL5", "irvh", "irfh",
				"etqh", "tsh", "tipo", "err", "cod", "etq", "esDesig");
		dependencias(desig.a("etqh"), expnivel5.a("etqh"));
		dependencias(desig.a("tsh"), expnivel5.a("tsh"));
		dependencias(expnivel5.a("tipo"), desig.a("tipo"));
		dependencias(expnivel5.a("err"), desig.a("err"));
		dependencias(expnivel5.a("cod"), desig.a("cod"), expnivel5.a("err"),
				expnivel5.a("tipo"));
		dependencias(expnivel5.a("etq"), desig.a("etq"));
		dependencias(expnivel5.a("esDesig"), desig.a("esDesig"));
		dependencias(desig.a("irvh"), expnivel5.a("irvh"));
		dependencias(desig.a("irfh"), expnivel5.a("irfh"));
		calculo(desig.a("tsh"), asignacion);
		calculo(desig.a("etqh"), asignacion);
		calculo(desig.a("irvh"), asignacion);
		calculo(desig.a("irfh"), asignacion);
		calculo(expnivel5.a("tipo"), asignacion);
		calculo(expnivel5.a("err"), copiaErrores);
		calculo(expnivel5.a("cod"), copiaCodigo);
		calculo(expnivel5.a("etq"), asignacion);
		calculo(expnivel5.a("esDesig"), asignacion);
		return expnivel5;
	}

	public TAtributos designador0(String iden) {
		regla("Designador -> Ident ");
		TAtributos designadorId = atributosPara("DESIGNADOR", "irvh", "irfh",
				"tsh", "etqh", "tipo", "err", "id", "cod", "etq", "esDesig");
		Atributo identificador = atributoLexicoPara("IDENTIFICADOR", "lex",
				iden);
		dependencias(designadorId.a("tipo"), identificador,
				designadorId.a("tsh"));
		dependencias(designadorId.a("err"), identificador,
				designadorId.a("tsh"));
		dependencias(designadorId.a("id"), identificador);
		dependencias(designadorId.a("cod"), identificador,
				designadorId.a("tsh"));
		dependencias(designadorId.a("etq"), designadorId.a("etqh"),
				identificador, designadorId.a("tsh"));
		calculo(designadorId.a("tipo"), dameTipoDeIdConTS);
		calculo(designadorId.a("err"), creaErroresDesigIden);
		calculo(designadorId.a("id"), asignacion);
		calculo(designadorId.a("cod"), codDesigIden);
		calculo(designadorId.a("etq"), etqDesigIden);
		calculo(designadorId.a("esDesig"), AsignTrueBool);
		return designadorId;
	}

	public TAtributos designador1(TAtributos desig1, TAtributos exp) {
		regla("Designador -> Designador [Exp]");
		TAtributos desig0 = atributosPara("DESIGNADOR", "tsh", "etqh", "irvh",
				"irfh", "id", "err", "tipo", "cod", "etq", "esDesig");
		dependencias(desig1.a("tsh"), desig0.a("tsh"));
		dependencias(desig1.a("etqh"), desig0.a("etqh"));
		dependencias(exp.a("tsh"), desig0.a("tsh"));
		dependencias(exp.a("etqh"), desig1.a("etq"));
		dependencias(desig0.a("tipo"), desig1.a("tipo"), exp.a("tipo"),
				desig0.a("tsh"));
		dependencias(desig0.a("cod"), desig1.a("cod"), exp.a("cod"),
				desig1.a("tipo"), desig0.a("tsh"), exp.a("esDesig"));
		dependencias(desig0.a("etq"), exp.a("etq"), exp.a("esDesig"));
		dependencias(desig0.a("id"), desig1.a("id"));
		dependencias(desig0.a("err"), desig1.a("err"), exp.a("err"));
		dependencias(desig1.a("irvh"), desig0.a("irvh"));
		dependencias(desig1.a("irfh"), desig0.a("irfh"));
		dependencias(exp.a("irvh"), desig0.a("irvh"));
		dependencias(exp.a("irfh"), desig0.a("irfh"));
		calculo(desig1.a("tsh"), asignacion);
		calculo(desig1.a("etqh"), asignacion);
		calculo(exp.a("tsh"), asignacion);
		calculo(exp.a("etqh"), asignacion);
		calculo(desig0.a("err"), unirDosErrores);
		calculo(desig0.a("tipo"), TipoDesignIndex);
		calculo(desig0.a("cod"), CodDesignIndex);
		calculo(desig0.a("etq"), EtqDesignIndex);
		calculo(desig0.a("esDesig"), AsignTrueBool);
		calculo(desig0.a("id"), asignacion);
		calculo(desig1.a("irvh"), asignacion);
		calculo(desig1.a("irfh"), asignacion);
		calculo(exp.a("irvh"), asignacion);
		calculo(exp.a("irfh"), asignacion);
		return desig0;
	}

	public TAtributos designador2(TAtributos desig1, String vnat) {
		regla("Designador -> Designador _ natural");
		TAtributos desig0 = atributosPara("DESIGNADOR", "tsh", "etqh", "irvh",
				"irfh", "id", "tipo", "cod", "etq", "err", "esDesig");
		Atributo pos = atributoLexicoPara("IDENTIFICADOR", "lex", vnat);
		dependencias(desig1.a("tsh"), desig0.a("tsh"));
		dependencias(desig1.a("etqh"), desig0.a("etqh"));
		dependencias(desig0.a("tipo"), desig1.a("tipo"), pos, desig0.a("tsh"));
		dependencias(desig0.a("cod"), desig1.a("cod"), desig1.a("tipo"), pos,
				desig0.a("tsh"));
		dependencias(desig0.a("etq"), desig1.a("etq"));
		dependencias(desig0.a("id"), desig1.a("id"));
		dependencias(desig0.a("err"), desig1.a("err"), desig1.a("tipo"), pos);
		dependencias(desig1.a("irvh"), desig0.a("irvh"));
		dependencias(desig1.a("irfh"), desig0.a("irfh"));
		calculo(desig1.a("tsh"), asignacion);
		calculo(desig1.a("etqh"), asignacion);
		calculo(desig0.a("tipo"), TipoDesignTupla);
		calculo(desig0.a("cod"), CodDesignTupla);
		calculo(desig0.a("etq"), asignacionSuma2);
		calculo(desig0.a("esDesig"), AsignTrueBool);
		calculo(desig0.a("id"), asignacion);
		calculo(desig0.a("err"), ConcatErroresDesignTupla);
		calculo(desig1.a("irvh"), asignacion);
		calculo(desig1.a("irfh"), asignacion);
		return desig0;
	}

	public TAtributos ops4Not() {
		regla("Ops4 -> not");
		TAtributos ops4 = atributosPara("OPS4", "op");
		calculo(ops4.a("op"), creaCodNot);
		return ops4;
	}

	public TAtributos ops4Menos() {
		regla("Ops4 -> -");
		TAtributos ops4 = atributosPara("OPS4", "op");
		calculo(ops4.a("op"), creaCodMenosUnario);
		return ops4;
	}

	public TAtributos ops4CastFloat() {
		regla("Ops4 -> (float)");
		TAtributos ops4 = atributosPara("OPS4", "op");
		calculo(ops4.a("op"), creaCodCastFloat);
		return ops4;
	}

	public TAtributos ops4CastInt() {
		regla("Ops4 -> (int)");
		TAtributos ops4 = atributosPara("OPS4", "op");
		calculo(ops4.a("op"), creaCodCastInt);
		return ops4;
	}

	public TAtributos ops4CastNat() {
		regla("Ops4 -> (nat)");
		TAtributos ops4 = atributosPara("OPS4", "op");
		calculo(ops4.a("op"), creaCodCastNat);
		return ops4;
	}

	public TAtributos ops4CastChar() {
		regla("Ops4 -> (char)");
		TAtributos ops4 = atributosPara("OPS4", "op");
		calculo(ops4.a("op"), creaCodCastChar);
		return ops4;
	}
}